//! Windows Live Messenger Library
//! Copyright (c) Microsoft Corporation. All rights reserved.
//! http://dev.live.com/messenger
//!

Type.createNamespace('Microsoft.Live.Core');

////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.INotifyCollectionChanged

Microsoft.Live.Core.INotifyCollectionChanged = function() { 
    /// <summary>
    /// Notifies listeners of dynamic changes, such as when items get
    /// added and removed or the whole list is refreshed.
    /// </summary>
};
Microsoft.Live.Core.INotifyCollectionChanged.prototype = {
    add_collectionChanged : null,
    remove_collectionChanged : null
}
Microsoft.Live.Core.INotifyCollectionChanged.createInterface('Microsoft.Live.Core.INotifyCollectionChanged');


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.INotifyPropertyChanged

Microsoft.Live.Core.INotifyPropertyChanged = function() { 
    /// <summary>
    /// Notifies clients that a property value has changed.
    /// </summary>
};
Microsoft.Live.Core.INotifyPropertyChanged.prototype = {
    add_propertyChanged : null,
    remove_propertyChanged : null
}
Microsoft.Live.Core.INotifyPropertyChanged.createInterface('Microsoft.Live.Core.INotifyPropertyChanged');


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.NotifyCollectionChangedAction

Microsoft.Live.Core.NotifyCollectionChangedAction = function() { 
    /// <summary>
    /// Describes the action that caused a <see cref="E:Microsoft.Live.Core.INotifyCollectionChanged.CollectionChanged" /> event.
    /// </summary>
    /// <field name="add" type="Number" integer="true" static="true">
    /// An item was added to the collection.
    /// </field>
    /// <field name="remove" type="Number" integer="true" static="true">
    /// An item was removed from the collection.
    /// </field>
    /// <field name="replaced" type="Number" integer="true" static="true">
    /// An item was replaced in the collection.
    /// </field>
    /// <field name="reset" type="Number" integer="true" static="true">
    /// The content of the collection has changed dramatically.
    /// </field>
};
Microsoft.Live.Core.NotifyCollectionChangedAction.prototype = {
    add: 0, 
    remove: 1, 
    replaced: 2, 
    reset: 3
}
Microsoft.Live.Core.NotifyCollectionChangedAction.createEnum('Microsoft.Live.Core.NotifyCollectionChangedAction', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.AuthenticationCompletedEventArgs

Microsoft.Live.Core.AuthenticationCompletedEventArgs = function Microsoft_Live_Core_AuthenticationCompletedEventArgs(identity) {
    /// <summary>
    /// Provides data for the <c>AuthenticationCompleted</c> event.
    /// </summary>
    /// <param name="identity" type="Microsoft.Live.Core.Identity">
    /// </param>
    Microsoft.Live.Core.AuthenticationCompletedEventArgs.constructBase(this);
}
Microsoft.Live.Core.AuthenticationCompletedEventArgs.prototype = {
    
    get_identity: function Microsoft_Live_Core_AuthenticationCompletedEventArgs$get_identity() {
        /// <summary>
        /// Gets the identity that was received.
        /// </summary>
        /// <value type="Microsoft.Live.Core.Identity"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.NotifyCollectionChangedEventArgs

Microsoft.Live.Core.NotifyCollectionChangedEventArgs = function Microsoft_Live_Core_NotifyCollectionChangedEventArgs(action, newItem, oldItem, index) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Core.INotifyCollectionChanged.CollectionChanged" /> event.
    /// </summary>
    /// <param name="action" type="Microsoft.Live.Core.NotifyCollectionChangedAction">
    /// The action that caused the event.
    /// </param>
    /// <param name="newItem" type="Object">
    /// The item that added.
    /// </param>
    /// <param name="oldItem" type="Object">
    /// The item that was removed.
    /// </param>
    /// <param name="index" type="Number" integer="true">
    /// The index of the item that changed.
    /// </param>
    Microsoft.Live.Core.NotifyCollectionChangedEventArgs.constructBase(this);
}
Microsoft.Live.Core.NotifyCollectionChangedEventArgs.prototype = {
    
    get_action: function Microsoft_Live_Core_NotifyCollectionChangedEventArgs$get_action() {
        /// <summary>
        /// Gets the action that caused the event.
        /// </summary>
        /// <value type="Microsoft.Live.Core.NotifyCollectionChangedAction"></value>
        return Microsoft.Live.Core.NotifyCollectionChangedAction.add;
    },
    
    get_newItems: function Microsoft_Live_Core_NotifyCollectionChangedEventArgs$get_newItems() {
        /// <summary>
        /// Gets the list of new items involved in the change.
        /// </summary>
        /// <value type="Array"></value>
        return null;
    },
    
    get_newStartingIndex: function Microsoft_Live_Core_NotifyCollectionChangedEventArgs$get_newStartingIndex() {
        /// <summary>
        /// Gets the index at which the change occurred.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_oldItems: function Microsoft_Live_Core_NotifyCollectionChangedEventArgs$get_oldItems() {
        /// <summary>
        /// Gets the list of items affected by a Replace, Remove, or Move action.
        /// </summary>
        /// <value type="Array"></value>
        return null;
    },
    
    get_oldStartingIndex: function Microsoft_Live_Core_NotifyCollectionChangedEventArgs$get_oldStartingIndex() {
        /// <summary>
        /// Gets the index at which a Move, Remove, ore Replace action occurred.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.PropertyChangedEventArgs

Microsoft.Live.Core.PropertyChangedEventArgs = function Microsoft_Live_Core_PropertyChangedEventArgs(propertyName) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Core.INotifyPropertyChanged.PropertyChanged" /> event.
    /// </summary>
    /// <param name="propertyName" type="String">
    /// The name of the property that changed.
    /// </param>
    Microsoft.Live.Core.PropertyChangedEventArgs.constructBase(this);
}
Microsoft.Live.Core.PropertyChangedEventArgs.prototype = {
    
    get_propertyName: function Microsoft_Live_Core_PropertyChangedEventArgs$get_propertyName() {
        /// <summary>
        /// Gets the name of the property that changed.
        /// </summary>
        /// <value type="String"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.Guid

Microsoft.Live.Core.Guid = function Microsoft_Live_Core_Guid(g) {
    /// <summary>
    /// Represents a globally unique identifier.
    /// </summary>
    /// <param name="g" type="String">
    /// A <see cref="T:System.String" /> that contains a GUID.
    /// </param>
}
Microsoft.Live.Core.Guid.prototype = {
    
    equals: function Microsoft_Live_Core_Guid$equals(guid) {
        /// <summary>
        /// Returns a value indicating whether two instances of <see cref="T:Microsoft.Live.Core.Guid" /> represent the same value.
        /// </summary>
        /// <param name="guid" type="Microsoft.Live.Core.Guid">
        /// A <see cref="T:Microsoft.Live.Core.Guid" /> object to compare to this instance.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    
    toString: function Microsoft_Live_Core_Guid$toString() {
        /// <summary>
        /// Returns a <see cref="T:System.String" /> representation of the value of this instance.
        /// </summary>
        /// <returns type="String"></returns>
        return '';
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.Uri

Microsoft.Live.Core.Uri = function Microsoft_Live_Core_Uri(uri) {
    /// <summary>
    /// Provides an object representation of a uniform resource identifier (URI).
    /// </summary>
    /// <param name="uri" type="String">
    /// A URI.
    /// </param>
}
Microsoft.Live.Core.Uri.get_uriSchemeHttp = function Microsoft_Live_Core_Uri$get_uriSchemeHttp() {
    /// <summary>
    /// Specifies that the URI is accessed through the Hypertext Transfer Protocol (HTTP).
    /// </summary>
    /// <value type="String"></value>
    return 'http';
}
Microsoft.Live.Core.Uri.prototype = {
    
    toString: function Microsoft_Live_Core_Uri$toString() {
        /// <summary>
        /// Returns a string for the <see cref="T:Microsoft.Live.Core.Uri" /> instance.
        /// </summary>
        /// <returns type="String"></returns>
        return '';
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.Version

Microsoft.Live.Core.Version = function Microsoft_Live_Core_Version(major, minor, build, revision) {
    /// <summary>
    /// Represents a version number.
    /// </summary>
    /// <param name="major" type="Number" integer="true">
    /// The major component.
    /// </param>
    /// <param name="minor" type="Number" integer="true">
    /// The minor component.
    /// </param>
    /// <param name="build" type="Number" integer="true">
    /// The build component.
    /// </param>
    /// <param name="revision" type="Number" integer="true">
    /// The revision component.
    /// </param>
}
Microsoft.Live.Core.Version.prototype = {
    
    get_major: function Microsoft_Live_Core_Version$get_major() {
        /// <summary>
        /// Gets the value of the major component of the version number for the current <see cref="T:Microsoft.Live.Core.Version" /> object.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_minor: function Microsoft_Live_Core_Version$get_minor() {
        /// <summary>
        /// Gets the value of the minor component of the version number for the current <see cref="T:Microsoft.Live.Core.Version" /> object.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_build: function Microsoft_Live_Core_Version$get_build() {
        /// <summary>
        /// Gets the value of the build component of the version number for the current <see cref="T:Microsoft.Live.Core.Version" /> object.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_revision: function Microsoft_Live_Core_Version$get_revision() {
        /// <summary>
        /// Gets the value of the revision component of the version number for the current <see cref="T:Microsoft.Live.Core.Version" /> object.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    toString: function Microsoft_Live_Core_Version$toString() {
        /// <summary>
        /// Converts the value of the current <see cref="T:Microsoft.Live.Core.Version" /> object to its equivalent <see cref="T:System.String" /> representation.
        /// </summary>
        /// <returns type="String"></returns>
        return '';
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Core.Identity

Microsoft.Live.Core.Identity = function Microsoft_Live_Core_Identity() {
    /// <summary>
    /// Represents a Windows Live identity.
    /// </summary>
}


Type.createNamespace('Microsoft.Live.Messenger');

////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.IMAddressType

Microsoft.Live.Messenger.IMAddressType = function() { 
    /// <summary>
    /// Represents an instant messaging address type.
    /// </summary>
    /// <field name="none" type="Number" integer="true" static="true">
    /// Indicates the lack of an address type.
    /// </field>
    /// <field name="windowsLive" type="Number" integer="true" static="true">
    /// Indicates the Windows Live address type.
    /// </field>
    /// <field name="officeCommunicator" type="Number" integer="true" static="true">
    /// Indicates the Office Communicator address type.
    /// </field>
    /// <field name="yahoo" type="Number" integer="true" static="true">
    /// Indicates the Yahoo address type.
    /// </field>
    /// <field name="telephone" type="Number" integer="true" static="true">
    /// Indicates the telephone address type.
    /// </field>
    /// <field name="smtp" type="Number" integer="true" static="true">
    /// Indicates the SMTP address type.
    /// </field>
    /// <field name="mobileNetwork" type="Number" integer="true" static="true">
    /// Indicates the mobile network address type.
    /// </field>
};
Microsoft.Live.Messenger.IMAddressType.prototype = {
    none: 0, 
    windowsLive: 1, 
    officeCommunicator: 2, 
    yahoo: 32, 
    telephone: 4, 
    smtp: 16, 
    mobileNetwork: 8
}
Microsoft.Live.Messenger.IMAddressType.createEnum('Microsoft.Live.Messenger.IMAddressType', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SignOutLocations

Microsoft.Live.Messenger.SignOutLocations = function() { 
    /// <summary>
    /// Represents the locations to be signed out.
    /// </summary>
    /// <field name="local" type="Number" integer="true" static="true">
    /// Indicates the local endpoint should be signed out.
    /// </field>
    /// <field name="remote" type="Number" integer="true" static="true">
    /// Indicates the remote endpoint(s) should be signed out.
    /// </field>
    /// <field name="all" type="Number" integer="true" static="true">
    /// Indicates all endpoints should be signed out.
    /// </field>
};
Microsoft.Live.Messenger.SignOutLocations.prototype = {
    local: 1, 
    remote: 2, 
    all: 3
}
Microsoft.Live.Messenger.SignOutLocations.createEnum('Microsoft.Live.Messenger.SignOutLocations', true);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.MessageType

Microsoft.Live.Messenger.MessageType = function() { 
    /// <summary>
    /// Specifies supported message types.
    /// </summary>
    /// <field name="textMessage" type="Number" integer="true" static="true">
    /// Represents a text message.
    /// </field>
    /// <field name="nudgeMessage" type="Number" integer="true" static="true">
    /// Represents a nudge message.
    /// </field>
    /// <field name="applicationMessage" type="Number" integer="true" static="true">
    /// Represents an application message
    /// </field>
};
Microsoft.Live.Messenger.MessageType.prototype = {
    textMessage: 1, 
    nudgeMessage: 2, 
    applicationMessage: 3
}
Microsoft.Live.Messenger.MessageType.createEnum('Microsoft.Live.Messenger.MessageType', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.TextMessageDirection

Microsoft.Live.Messenger.TextMessageDirection = function() { 
    /// <summary>
    /// Defines constants that specify the content flow direction for text and user interface (UI) elements.
    /// </summary>
    /// <field name="leftToRight" type="Number" integer="true" static="true">
    /// Indicates that content should flow from left to right.
    /// </field>
    /// <field name="rightToLeft" type="Number" integer="true" static="true">
    /// Indicates that content should flow from right to left.
    /// </field>
};
Microsoft.Live.Messenger.TextMessageDirection.prototype = {
    leftToRight: 0, 
    rightToLeft: 1
}
Microsoft.Live.Messenger.TextMessageDirection.createEnum('Microsoft.Live.Messenger.TextMessageDirection', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.TextMessageStyle

Microsoft.Live.Messenger.TextMessageStyle = function() { 
    /// <summary>
    /// Represents a font style.
    /// </summary>
    /// <field name="regular" type="Number" integer="true" static="true">
    /// Normal text.
    /// </field>
    /// <field name="bold" type="Number" integer="true" static="true">
    /// Bold text.
    /// </field>
    /// <field name="italic" type="Number" integer="true" static="true">
    /// Italic text.
    /// </field>
    /// <field name="strikeout" type="Number" integer="true" static="true">
    /// Text with a line through the middle.
    /// </field>
    /// <field name="underline" type="Number" integer="true" static="true">
    /// Underlined text.
    /// </field>
};
Microsoft.Live.Messenger.TextMessageStyle.prototype = {
    regular: 0, 
    bold: 1, 
    italic: 2, 
    strikeout: 4, 
    underline: 8
}
Microsoft.Live.Messenger.TextMessageStyle.createEnum('Microsoft.Live.Messenger.TextMessageStyle', true);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.PresenceStatus

Microsoft.Live.Messenger.PresenceStatus = function() { 
    /// <summary>
    /// Represents the status of an instant messaging address.
    /// </summary>
    /// <field name="offline" type="Number" integer="true" static="true">
    /// Indicates the address is offline.
    /// </field>
    /// <field name="online" type="Number" integer="true" static="true">
    /// Indicates the address is online.
    /// </field>
    /// <field name="appearOffline" type="Number" integer="true" static="true">
    /// Indicates the address should appear as offline to other addresses.
    /// </field>
    /// <field name="busy" type="Number" integer="true" static="true">
    /// Indicates the address is busy.
    /// </field>
    /// <field name="idle" type="Number" integer="true" static="true">
    /// Indicates the address is idle.
    /// </field>
    /// <field name="beRightBack" type="Number" integer="true" static="true">
    /// Indicates the address will be back soon.
    /// </field>
    /// <field name="away" type="Number" integer="true" static="true">
    /// Indicates the address is away.
    /// </field>
    /// <field name="inACall" type="Number" integer="true" static="true">
    /// Indicates the address is in a phone call.
    /// </field>
    /// <field name="outToLunch" type="Number" integer="true" static="true">
    /// Indicates the address is out to lunch.
    /// </field>
};
Microsoft.Live.Messenger.PresenceStatus.prototype = {
    offline: 0, 
    online: 1, 
    appearOffline: 2, 
    busy: 3, 
    idle: 4, 
    beRightBack: 5, 
    away: 6, 
    inACall: 7, 
    outToLunch: 8
}
Microsoft.Live.Messenger.PresenceStatus.createEnum('Microsoft.Live.Messenger.PresenceStatus', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.PrivacyMode

Microsoft.Live.Messenger.PrivacyMode = function() { 
    /// <summary>
    /// Represents the user's desired privacy mode.
    /// </summary>
    /// <field name="allowByDefault" type="Number" integer="true" static="true">
    /// Indicates that addresses should be allowed by default.
    /// </field>
    /// <field name="blockByDefault" type="Number" integer="true" static="true">
    /// Indicates that addresses should be blocked by default.
    /// </field>
};
Microsoft.Live.Messenger.PrivacyMode.prototype = {
    allowByDefault: 0, 
    blockByDefault: 1
}
Microsoft.Live.Messenger.PrivacyMode.createEnum('Microsoft.Live.Messenger.PrivacyMode', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.AddContactResultCode

Microsoft.Live.Messenger.AddContactResultCode = function() { 
    /// <summary>
    /// Represents result codes for <see cref="M:Microsoft.Live.Messenger.User.AddContact(System.String,System.String,System.Object)" />.
    /// </summary>
    /// <field name="success" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.User.AddContact(System.String,System.String,System.Object)" /> completed successfully.
    /// </field>
    /// <field name="failure" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.User.AddContact(System.String,System.String,System.Object)" /> failed.
    /// </field>
    /// <field name="notFound" type="Number" integer="true" static="true">
    /// Indicates the address provided to <see cref="M:Microsoft.Live.Messenger.User.AddContact(System.String,System.String,System.Object)" /> could not be found.
    /// </field>
};
Microsoft.Live.Messenger.AddContactResultCode.prototype = {
    success: 0, 
    failure: 1, 
    notFound: 2
}
Microsoft.Live.Messenger.AddContactResultCode.createEnum('Microsoft.Live.Messenger.AddContactResultCode', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.InviteAddressResultCode

Microsoft.Live.Messenger.InviteAddressResultCode = function() { 
    /// <summary>
    /// Represents result codes for <see cref="M:Microsoft.Live.Messenger.Conversation.InviteAddress(Microsoft.Live.Messenger.IMAddress,System.Object)" />.
    /// </summary>
    /// <field name="success" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.Conversation.InviteAddress(Microsoft.Live.Messenger.IMAddress,System.Object)" /> completed successfully.
    /// </field>
    /// <field name="failure" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.Conversation.InviteAddress(Microsoft.Live.Messenger.IMAddress,System.Object)" /> did not complete succesfully.
    /// </field>
};
Microsoft.Live.Messenger.InviteAddressResultCode.prototype = {
    success: 0, 
    failure: 1
}
Microsoft.Live.Messenger.InviteAddressResultCode.createEnum('Microsoft.Live.Messenger.InviteAddressResultCode', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SendMessageResultCode

Microsoft.Live.Messenger.SendMessageResultCode = function() { 
    /// <summary>
    /// Represents result codes for <see cref="M:Microsoft.Live.Messenger.Conversation.SendMessage(Microsoft.Live.Messenger.Message,System.Object)" />
    /// </summary>
    /// <field name="success" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.Conversation.SendMessage(Microsoft.Live.Messenger.Message,System.Object)" /> completed successfully.
    /// </field>
    /// <field name="failure" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.Conversation.SendMessage(Microsoft.Live.Messenger.Message,System.Object)" /> failed.
    /// </field>
};
Microsoft.Live.Messenger.SendMessageResultCode.prototype = {
    success: 0, 
    failure: 1
}
Microsoft.Live.Messenger.SendMessageResultCode.createEnum('Microsoft.Live.Messenger.SendMessageResultCode', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SignOutResultCode

Microsoft.Live.Messenger.SignOutResultCode = function() { 
    /// <summary>
    /// Represents result codes for <see cref="M:Microsoft.Live.Messenger.User.SignOut(Microsoft.Live.Messenger.SignOutLocations,System.Object)" />.
    /// </summary>
    /// <field name="success" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.User.SignOut(Microsoft.Live.Messenger.SignOutLocations,System.Object)" /> completed successfully.
    /// </field>
    /// <field name="failure" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.User.SignOut(Microsoft.Live.Messenger.SignOutLocations,System.Object)" /> failed.
    /// </field>
};
Microsoft.Live.Messenger.SignOutResultCode.prototype = {
    success: 0, 
    failure: 1
}
Microsoft.Live.Messenger.SignOutResultCode.createEnum('Microsoft.Live.Messenger.SignOutResultCode', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SignInResultCode

Microsoft.Live.Messenger.SignInResultCode = function() { 
    /// <summary>
    /// Represents result codes for <see cref="M:Microsoft.Live.Messenger.User.SignIn(System.Object)" />.
    /// </summary>
    /// <field name="success" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.User.SignIn(System.Object)" /> completed successfully.
    /// </field>
    /// <field name="failure" type="Number" integer="true" static="true">
    /// Indicates <see cref="M:Microsoft.Live.Messenger.User.SignIn(System.Object)" /> failed.
    /// </field>
};
Microsoft.Live.Messenger.SignInResultCode.prototype = {
    success: 0, 
    failure: 1
}
Microsoft.Live.Messenger.SignInResultCode.createEnum('Microsoft.Live.Messenger.SignInResultCode', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.MailFolder

Microsoft.Live.Messenger.MailFolder = function() { 
    /// <summary>
    /// Represents a Hotmail folder.
    /// </summary>
    /// <field name="inbox" type="Number" integer="true" static="true">
    /// The inbox
    /// </field>
    /// <field name="deleted" type="Number" integer="true" static="true">
    /// The deleted items folder
    /// </field>
    /// <field name="junk" type="Number" integer="true" static="true">
    /// The junk mail folder
    /// </field>
    /// <field name="sent" type="Number" integer="true" static="true">
    /// The sent items folder
    /// </field>
    /// <field name="drafts" type="Number" integer="true" static="true">
    /// The drafts folder
    /// </field>
    /// <field name="other" type="Number" integer="true" static="true">
    /// A different folder
    /// </field>
};
Microsoft.Live.Messenger.MailFolder.prototype = {
    inbox: 0, 
    deleted: 1, 
    junk: 2, 
    sent: 3, 
    drafts: 4, 
    other: 5
}
Microsoft.Live.Messenger.MailFolder.createEnum('Microsoft.Live.Messenger.MailFolder', false);


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.AddressChangingEventArgs

Microsoft.Live.Messenger.AddressChangingEventArgs = function Microsoft_Live_Messenger_AddressChangingEventArgs(oldAddress, newAddress) {
    /// <summary>
    /// Provides data for the <see cref="T:Microsoft.Live.Messenger.AddressChangingEventHandler" /> event.
    /// </summary>
    /// <param name="oldAddress" type="Microsoft.Live.Messenger.IMAddress">
    /// The old address.
    /// </param>
    /// <param name="newAddress" type="Microsoft.Live.Messenger.IMAddress">
    /// The new address.
    /// </param>
    Microsoft.Live.Messenger.AddressChangingEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.AddressChangingEventArgs.prototype = {
    
    get_oldAddress: function Microsoft_Live_Messenger_AddressChangingEventArgs$get_oldAddress() {
        /// <summary>
        /// The old address
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_newAddress: function Microsoft_Live_Messenger_AddressChangingEventArgs$get_newAddress() {
        /// <summary>
        /// The new address
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.IMAddressPresence

Microsoft.Live.Messenger.IMAddressPresence = function Microsoft_Live_Messenger_IMAddressPresence() {
    /// <summary>
    /// Represents presence information associated with an instant messaging address, such as status, IM address, display name, display picture URL, and so on.
    /// </summary>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.IMAddressPresence.isDisplayNameValid = function Microsoft_Live_Messenger_IMAddressPresence$isDisplayNameValid(displayName) {
    /// <summary>
    /// Determines whether the provided display name is valid.
    /// </summary>
    /// <param name="displayName" type="String">
    /// The display name to validate.
    /// </param>
    /// <returns type="Boolean"></returns>
    return false;
}
Microsoft.Live.Messenger.IMAddressPresence.isPersonalMessageValid = function Microsoft_Live_Messenger_IMAddressPresence$isPersonalMessageValid(message) {
    /// <summary>
    /// Determines whether the provided personal message is valid.
    /// </summary>
    /// <param name="message" type="String">
    /// The personal message to validate.
    /// </param>
    /// <returns type="Boolean"></returns>
    return false;
}
Microsoft.Live.Messenger.IMAddressPresence.prototype = {
    
    get_imAddress: function Microsoft_Live_Messenger_IMAddressPresence$get_imAddress() {
        /// <summary>
        /// Gets the associated instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_properties: function Microsoft_Live_Messenger_IMAddressPresence$get_properties() {
        /// <summary>
        /// Gets the properties associated with the address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PresencePropertyCollection"></value>
        return null;
    },
    
    get_displayName: function Microsoft_Live_Messenger_IMAddressPresence$get_displayName() {
        /// <summary>
        /// Gets the display name for the instant messaging address.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    set_displayName: function Microsoft_Live_Messenger_IMAddressPresence$set_displayName(value) {
        /// <summary>
        /// Gets the display name for the instant messaging address.
        /// </summary>
        /// <value type="String"></value>
        return value;
    },
    
    get_displayPictureUrl: function Microsoft_Live_Messenger_IMAddressPresence$get_displayPictureUrl() {
        /// <summary>
        /// Gets the display picture URL for the instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Core.Uri"></value>
        return null;
    },
    
    get_personalMessage: function Microsoft_Live_Messenger_IMAddressPresence$get_personalMessage() {
        /// <summary>
        /// Gets the personal message for the instant messaging address.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    set_personalMessage: function Microsoft_Live_Messenger_IMAddressPresence$set_personalMessage(value) {
        /// <summary>
        /// Gets the personal message for the instant messaging address.
        /// </summary>
        /// <value type="String"></value>
        return value;
    },
    
    get_status: function Microsoft_Live_Messenger_IMAddressPresence$get_status() {
        /// <summary>
        /// Gets the status for the instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PresenceStatus"></value>
        return Microsoft.Live.Messenger.PresenceStatus.online;
    },
    set_status: function Microsoft_Live_Messenger_IMAddressPresence$set_status(value) {
        /// <summary>
        /// Gets the status for the instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PresenceStatus"></value>
        return value;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_IMAddressPresence$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_IMAddressPresence$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_IMAddressPresence$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.IMAddressPresence.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.PresenceProperty

Microsoft.Live.Messenger.PresenceProperty = function Microsoft_Live_Messenger_PresenceProperty(name, value) {
    /// <summary>
    /// Represents a presence property.
    /// </summary>
    /// <param name="name" type="String">
    /// The name.
    /// </param>
    /// <param name="value" type="String">
    /// The value.
    /// </param>
}
Microsoft.Live.Messenger.PresenceProperty.prototype = {
    
    get_name: function Microsoft_Live_Messenger_PresenceProperty$get_name() {
        /// <summary>
        /// Gets the name.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    get_value: function Microsoft_Live_Messenger_PresenceProperty$get_value() {
        /// <summary>
        /// Gets the value.
        /// </summary>
        /// <value type="String"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Collection

Microsoft.Live.Messenger.Collection = function Microsoft_Live_Messenger_Collection() {
    /// <summary>
    /// Represents a generic collection.
    /// </summary>
    /// <field name="__collectionChanged" type="Microsoft.Live.Core.NotifyCollectionChangedEventHandler">
    /// </field>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Collection.prototype = {
    
    add_collectionChanged: function Microsoft_Live_Messenger_Collection$add_collectionChanged(value) {
        /// <summary>
        /// Occurs when the collection changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__collectionChanged = Delegate.combine(this.__collectionChanged, value);
    },
    remove_collectionChanged: function Microsoft_Live_Messenger_Collection$remove_collectionChanged(value) {
        /// <summary>
        /// Occurs when the collection changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__collectionChanged = Delegate.remove(this.__collectionChanged, value);
    },
    
    __collectionChanged: null,
    
    add_propertyChanged: function Microsoft_Live_Messenger_Collection$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Collection$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    onCollectionChanged: function Microsoft_Live_Messenger_Collection$onCollectionChanged(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Collection.CollectionChanged" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Core.NotifyCollectionChangedEventArgs">
        /// The event data.
        /// </param>
        if (this.__collectionChanged) {
            this.__collectionChanged.invoke(this, e);
        }
    },
    
    onPropertyChanged: function Microsoft_Live_Messenger_Collection$onPropertyChanged(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Collection.PropertyChanged" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Core.PropertyChangedEventArgs">
        /// The event data.
        /// </param>
        if (this.__propertyChanged) {
            this.__propertyChanged.invoke(this, e);
        }
    },
    
    get_count: function Microsoft_Live_Messenger_Collection$get_count() {
        /// <summary>
        /// Gets the number of items in the collection.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    contains: function Microsoft_Live_Messenger_Collection$contains(obj) {
        /// <summary>
        /// Determines whether the object is within the collection.
        /// </summary>
        /// <param name="obj" type="Object">
        /// The object.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    
    getEnumerator: function Microsoft_Live_Messenger_Collection$getEnumerator() {
        /// <summary>
        /// Gets the enumerator.
        /// </summary>
        /// <returns type="IEnumerator"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Contact

Microsoft.Live.Messenger.Contact = function Microsoft_Live_Messenger_Contact() {
    /// <summary>
    /// Represents a single contact.
    /// </summary>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
    /// <field name="__currentAddressChanging" type="Microsoft.Live.Messenger.AddressChangingEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Contact.prototype = {
    
    block: function Microsoft_Live_Messenger_Contact$block() {
        /// <summary>
        /// Blocks the contact from viewing the user's presence and initiating
        /// conversations with the user.
        /// </summary>
    },
    
    allow: function Microsoft_Live_Messenger_Contact$allow() {
        /// <summary>
        /// Allows the contact to view the user's presence and initiate
        /// conversations with the user.
        /// </summary>
    },
    
    get_addresses: function Microsoft_Live_Messenger_Contact$get_addresses() {
        /// <summary>
        /// All of the <see cref="T:Microsoft.Live.Messenger.IMAddress" />es for the contact.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddressCollection"></value>
        return null;
    },
    
    get_currentAddress: function Microsoft_Live_Messenger_Contact$get_currentAddress() {
        /// <summary>
        /// The current <see cref="T:Microsoft.Live.Messenger.IMAddress" /> that should be displayed in the UI. This Address is also
        /// the address that should be used to start a new conversation after (for example) double clicking
        /// the contact in the UI.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_groups: function Microsoft_Live_Messenger_Contact$get_groups() {
        /// <summary>
        /// Gets the groups that the instant messaging address belongs to.
        /// </summary>
        /// <value type="Array" elementType="Group"></value>
        return null;
    },
    
    get_isAllowed: function Microsoft_Live_Messenger_Contact$get_isAllowed() {
        /// <summary>
        /// Gets whether the address is allowed to view the user's presence.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_isBlocked: function Microsoft_Live_Messenger_Contact$get_isBlocked() {
        /// <summary>
        /// Gets whether the address is blocked from viewing the user's presence.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_Contact$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Contact$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_Contact$_onPropertyChanged() {
        if (this.__propertyChanged) {
        }
    },
    
    add_currentAddressChanging: function Microsoft_Live_Messenger_Contact$add_currentAddressChanging(value) {
        /// <summary>
        /// Raised when the current address of the contact is changed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__currentAddressChanging = Delegate.combine(this.__currentAddressChanging, value);
    },
    remove_currentAddressChanging: function Microsoft_Live_Messenger_Contact$remove_currentAddressChanging(value) {
        /// <summary>
        /// Raised when the current address of the contact is changed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__currentAddressChanging = Delegate.remove(this.__currentAddressChanging, value);
    },
    
    __currentAddressChanging: null,
    
    _onCurrentAddressChanging: function Microsoft_Live_Messenger_Contact$_onCurrentAddressChanging(oldAddress, newAddress) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Contact.CurrentAddressChanging" /> event
        /// </summary>
        /// <param name="oldAddress" type="Microsoft.Live.Messenger.IMAddress">
        /// </param>
        /// <param name="newAddress" type="Microsoft.Live.Messenger.IMAddress">
        /// </param>
        if (this.__currentAddressChanging) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.ContactCollection

Microsoft.Live.Messenger.ContactCollection = function Microsoft_Live_Messenger_ContactCollection() {
    /// <summary>
    /// Represents a collection of contacts.
    /// </summary>
    Microsoft.Live.Messenger.ContactCollection.constructBase(this);
}
Microsoft.Live.Messenger.ContactCollection.prototype = {
    
    get_capacity: function Microsoft_Live_Messenger_ContactCollection$get_capacity() {
        /// <summary>
        /// Gets the maximum number of contacts that the user can have within this collection.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    add: function Microsoft_Live_Messenger_ContactCollection$add(contact) {
        /// <summary>
        /// Adds a contact to the collection.
        /// </summary>
        /// <param name="contact" type="Microsoft.Live.Messenger.Contact">
        /// The contact to add.
        /// </param>
    },
    
    remove: function Microsoft_Live_Messenger_ContactCollection$remove(contact) {
        /// <summary>
        /// Removes a contact from the collection.
        /// </summary>
        /// <param name="contact" type="Microsoft.Live.Messenger.Contact">
        /// The contact to remove.
        /// </param>
    },
    
    findByAddress: function Microsoft_Live_Messenger_ContactCollection$findByAddress(address) {
        /// <summary>
        /// Attempts to find a <see cref="T:Microsoft.Live.Messenger.Contact" />.
        /// </summary>
        /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
        /// The IM address of the contact
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Contact"></returns>
        return null;
    },
    
    find: function Microsoft_Live_Messenger_ContactCollection$find(address, addressType) {
        /// <summary>
        /// Attempts to find a <see cref="T:Microsoft.Live.Messenger.Contact" />.
        /// </summary>
        /// <param name="address" type="String">
        /// The address of the contact
        /// </param>
        /// <param name="addressType" type="Microsoft.Live.Messenger.IMAddressType">
        /// The address type of the contact
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Contact"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.EndpointPresence

Microsoft.Live.Messenger.EndpointPresence = function Microsoft_Live_Messenger_EndpointPresence() {
    /// <summary>
    /// Represents presence information associated with an endpoint.
    /// </summary>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.EndpointPresence.prototype = {
    
    get_properties: function Microsoft_Live_Messenger_EndpointPresence$get_properties() {
        /// <summary>
        /// Gets the properties associated with the endpoint.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PresencePropertyCollection"></value>
        return null;
    },
    
    get_extensions: function Microsoft_Live_Messenger_EndpointPresence$get_extensions() {
        /// <summary>
        /// Gets the custom properties associated with the endpoint.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Presence.PresenceExtensionCollection"></value>
        return null;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_EndpointPresence$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_EndpointPresence$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_EndpointPresence$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.EndpointPresence.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.ConversationCollection

Microsoft.Live.Messenger.ConversationCollection = function Microsoft_Live_Messenger_ConversationCollection(user) {
    /// <summary>
    /// Represents a collection of conversations.
    /// </summary>
    /// <param name="user" type="Microsoft.Live.Messenger.User">
    /// The associated user.
    /// </param>
    Microsoft.Live.Messenger.ConversationCollection.constructBase(this);
}
Microsoft.Live.Messenger.ConversationCollection.prototype = {
    
    create: function Microsoft_Live_Messenger_ConversationCollection$create(address) {
        /// <summary>
        /// Creates a conversation with the specified instant messaging address.
        /// </summary>
        /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Conversation"></returns>
        return null;
    },
    get_item: function Microsoft_Live_Messenger_ConversationCollection$get_item(index) {
        /// <summary>
        /// Gets the <c>Conversation</c> at the specific index.
        /// </summary>
        /// <param name="index" type="Number" integer="true">
        /// The zero-based index of the <c>Conversation</c> to get.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.Conversation">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Conversation"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.EndpointCollection

Microsoft.Live.Messenger.EndpointCollection = function Microsoft_Live_Messenger_EndpointCollection() {
    /// <summary>
    /// Represents a collection of endpoints.
    /// </summary>
    Microsoft.Live.Messenger.EndpointCollection.constructBase(this);
}
Microsoft.Live.Messenger.EndpointCollection.prototype = {
    get_item: function Microsoft_Live_Messenger_EndpointCollection$get_item(index) {
        /// <summary>
        /// Gets the <c>Endpoint</c> at the specific index.
        /// </summary>
        /// <param name="index" type="Number" integer="true">
        /// The zero-based index of the <c>Endpoint</c> to get.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.Endpoint">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Endpoint"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.AddContactCompletedEventArgs

Microsoft.Live.Messenger.AddContactCompletedEventArgs = function Microsoft_Live_Messenger_AddContactCompletedEventArgs(resultCode, contact, userState) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.User.AddContactCompleted" /> event.
    /// </summary>
    /// <param name="resultCode" type="Microsoft.Live.Messenger.AddContactResultCode">
    /// The result code.
    /// </param>
    /// <param name="contact" type="Microsoft.Live.Messenger.Contact">
    /// The contact that was added.
    /// </param>
    /// <param name="userState" type="Object">
    /// The user state.
    /// </param>
    Microsoft.Live.Messenger.AddContactCompletedEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.AddContactCompletedEventArgs.prototype = {
    
    get_resultCode: function Microsoft_Live_Messenger_AddContactCompletedEventArgs$get_resultCode() {
        /// <summary>
        /// Gets the result code.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.AddContactResultCode"></value>
        return Microsoft.Live.Messenger.AddContactResultCode.success;
    },
    
    get_contact: function Microsoft_Live_Messenger_AddContactCompletedEventArgs$get_contact() {
        /// <summary>
        /// Gets the contact that was added.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Contact"></value>
        return null;
    },
    
    get_userState: function Microsoft_Live_Messenger_AddContactCompletedEventArgs$get_userState() {
        /// <summary>
        /// Gets the unique identifier for the asynchronous task.
        /// </summary>
        /// <value type="Object"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.InviteAddressCompletedEventArgs

Microsoft.Live.Messenger.InviteAddressCompletedEventArgs = function Microsoft_Live_Messenger_InviteAddressCompletedEventArgs(resultCode, address, userState) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.Conversation.InviteAddressCompleted" /> event.
    /// </summary>
    /// <param name="resultCode" type="Microsoft.Live.Messenger.InviteAddressResultCode">
    /// The result code.
    /// </param>
    /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
    /// The address that was invited.
    /// </param>
    /// <param name="userState" type="Object">
    /// The user state.
    /// </param>
    Microsoft.Live.Messenger.InviteAddressCompletedEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.InviteAddressCompletedEventArgs.prototype = {
    
    get_resultCode: function Microsoft_Live_Messenger_InviteAddressCompletedEventArgs$get_resultCode() {
        /// <summary>
        /// Gets the result code.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.InviteAddressResultCode"></value>
        return Microsoft.Live.Messenger.InviteAddressResultCode.success;
    },
    
    get_imAddress: function Microsoft_Live_Messenger_InviteAddressCompletedEventArgs$get_imAddress() {
        /// <summary>
        /// Gets the IM address
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_userState: function Microsoft_Live_Messenger_InviteAddressCompletedEventArgs$get_userState() {
        /// <summary>
        /// Gets the unique identifier for the asynchronous task.
        /// </summary>
        /// <value type="Object"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.MessageReceivedEventArgs

Microsoft.Live.Messenger.MessageReceivedEventArgs = function Microsoft_Live_Messenger_MessageReceivedEventArgs(message) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.Conversation.MessageReceived" /> event.
    /// </summary>
    /// <param name="message" type="Microsoft.Live.Messenger.Message">
    /// The message that was received.
    /// </param>
    Microsoft.Live.Messenger.MessageReceivedEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.MessageReceivedEventArgs.prototype = {
    
    get_message: function Microsoft_Live_Messenger_MessageReceivedEventArgs$get_message() {
        /// <summary>
        /// Gets the message that was received.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Message"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SendMessageFailedEventArgs

Microsoft.Live.Messenger.SendMessageFailedEventArgs = function Microsoft_Live_Messenger_SendMessageFailedEventArgs(resultCode, message, userState) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.Conversation.SendMessageFailed" /> event.
    /// </summary>
    /// <param name="resultCode" type="Microsoft.Live.Messenger.SendMessageResultCode">
    /// The result code.
    /// </param>
    /// <param name="message" type="Microsoft.Live.Messenger.Message">
    /// The message that could not be delivered.
    /// </param>
    /// <param name="userState" type="Object">
    /// The user state
    /// </param>
    Microsoft.Live.Messenger.SendMessageFailedEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.SendMessageFailedEventArgs.prototype = {
    
    get_resultCode: function Microsoft_Live_Messenger_SendMessageFailedEventArgs$get_resultCode() {
        /// <summary>
        /// Gets the result code.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.SendMessageResultCode"></value>
        return Microsoft.Live.Messenger.SendMessageResultCode.success;
    },
    
    get_message: function Microsoft_Live_Messenger_SendMessageFailedEventArgs$get_message() {
        /// <summary>
        /// Gets the message that could not be delivered.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Message"></value>
        return null;
    },
    
    get_userState: function Microsoft_Live_Messenger_SendMessageFailedEventArgs$get_userState() {
        /// <summary>
        /// Gets the user state
        /// </summary>
        /// <value type="Object"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SignedOutRemotelyEventArgs

Microsoft.Live.Messenger.SignedOutRemotelyEventArgs = function Microsoft_Live_Messenger_SignedOutRemotelyEventArgs() {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.User.SignedOutRemotely" /> event.
    /// </summary>
    Microsoft.Live.Messenger.SignedOutRemotelyEventArgs.constructBase(this);
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SignInCompletedEventArgs

Microsoft.Live.Messenger.SignInCompletedEventArgs = function Microsoft_Live_Messenger_SignInCompletedEventArgs(resultCode, userState) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.User.SignInCompleted" /> event.
    /// </summary>
    /// <param name="resultCode" type="Microsoft.Live.Messenger.SignInResultCode">
    /// The result code.
    /// </param>
    /// <param name="userState" type="Object">
    /// The user state.
    /// </param>
    Microsoft.Live.Messenger.SignInCompletedEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.SignInCompletedEventArgs.prototype = {
    
    get_resultCode: function Microsoft_Live_Messenger_SignInCompletedEventArgs$get_resultCode() {
        /// <summary>
        /// Gets the result code.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.SignInResultCode"></value>
        return Microsoft.Live.Messenger.SignInResultCode.success;
    },
    
    get_userState: function Microsoft_Live_Messenger_SignInCompletedEventArgs$get_userState() {
        /// <summary>
        /// Gets the unique identifier for the asynchronous task.
        /// </summary>
        /// <value type="Object"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.SignOutCompletedEventArgs

Microsoft.Live.Messenger.SignOutCompletedEventArgs = function Microsoft_Live_Messenger_SignOutCompletedEventArgs(resultCode, userState) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.User.SignOutCompleted" /> event.
    /// </summary>
    /// <param name="resultCode" type="Microsoft.Live.Messenger.SignOutResultCode">
    /// The result code.
    /// </param>
    /// <param name="userState" type="Object">
    /// The user state.
    /// </param>
    Microsoft.Live.Messenger.SignOutCompletedEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.SignOutCompletedEventArgs.prototype = {
    
    get_resultCode: function Microsoft_Live_Messenger_SignOutCompletedEventArgs$get_resultCode() {
        /// <summary>
        /// Gets the result code.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.SignOutResultCode"></value>
        return Microsoft.Live.Messenger.SignOutResultCode.success;
    },
    
    get_userState: function Microsoft_Live_Messenger_SignOutCompletedEventArgs$get_userState() {
        /// <summary>
        /// Gets the unique identifier for the asynchronous task.
        /// </summary>
        /// <value type="Object"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.GroupCollection

Microsoft.Live.Messenger.GroupCollection = function Microsoft_Live_Messenger_GroupCollection() {
    /// <summary>
    /// Represents a collection of groups.
    /// </summary>
    Microsoft.Live.Messenger.GroupCollection.constructBase(this);
}
Microsoft.Live.Messenger.GroupCollection.prototype = {
    
    get_capacity: function Microsoft_Live_Messenger_GroupCollection$get_capacity() {
        /// <summary>
        /// Gets the maximum number of groups that a user can have in this collection.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    create: function Microsoft_Live_Messenger_GroupCollection$create(groupName) {
        /// <summary>
        /// Creates a new group.
        /// </summary>
        /// <param name="groupName" type="String">
        /// The name of the group.
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Group"></returns>
        return null;
    },
    
    remove: function Microsoft_Live_Messenger_GroupCollection$remove(group) {
        /// <summary>
        /// Removes a group from the collection.
        /// </summary>
        /// <param name="group" type="Microsoft.Live.Messenger.Group">
        /// The group to remove.
        /// </param>
    },
    
    isNameValid: function Microsoft_Live_Messenger_GroupCollection$isNameValid(groupName) {
        /// <summary>
        /// Determines whether the provided group name is valid.
        /// </summary>
        /// <param name="groupName" type="String">
        /// The name to validate.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    get_item: function Microsoft_Live_Messenger_GroupCollection$get_item(name) {
        /// <summary>
        /// Gets the <c>Group</c> by name.
        /// </summary>
        /// <param name="name" type="String">
        /// The name of the group.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.Group">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Group"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Capabilities

Microsoft.Live.Messenger.Capabilities = function Microsoft_Live_Messenger_Capabilities(address) {
    /// <summary>
    /// Represents the capabilities of an address or endpoint.
    /// </summary>
    /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
    /// The associated address.
    /// </param>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Capabilities.prototype = {
    
    get_isOnlineViaMobileDevice: function Microsoft_Live_Messenger_Capabilities$get_isOnlineViaMobileDevice() {
        /// <summary>
        /// Gets whether the address or endpoint is online via a mobile device.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_isOnlineViaWeb: function Microsoft_Live_Messenger_Capabilities$get_isOnlineViaWeb() {
        /// <summary>
        /// Gets whether the address or endpoint is online via the web.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_version: function Microsoft_Live_Messenger_Capabilities$get_version() {
        /// <summary>
        /// Gets the client version for the address or endpoint.
        /// </summary>
        /// <value type="Microsoft.Live.Core.Version"></value>
        return null;
    },
    
    get_supportsMultipartyConversations: function Microsoft_Live_Messenger_Capabilities$get_supportsMultipartyConversations() {
        /// <summary>
        /// Gets whether the address or endpoint supports multiparty conversations.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    supportsMessageType: function Microsoft_Live_Messenger_Capabilities$supportsMessageType(messageType) {
        /// <summary>
        /// Gets whether the address supports the provided message type.
        /// </summary>
        /// <param name="messageType" type="Microsoft.Live.Messenger.MessageType">
        /// </param>
        /// <returns type="Boolean"></returns>
        return true;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_Capabilities$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Capabilities$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_Capabilities$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Capabilities.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Conversation

Microsoft.Live.Messenger.Conversation = function Microsoft_Live_Messenger_Conversation(user, address) {
    /// <summary>
    /// Represents a conversation between two or more instant messaging addresses.
    /// </summary>
    /// <param name="user" type="Microsoft.Live.Messenger.User">
    /// The user who initiates the conversation.
    /// </param>
    /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
    /// The instant messaging address of the contact with which to converse.
    /// </param>
    /// <field name="__inviteAddressCompleted" type="Microsoft.Live.Messenger.InviteAddressCompletedEventHandler">
    /// </field>
    /// <field name="__sendMessageFailed" type="Microsoft.Live.Messenger.SendMessageFailedEventHandler">
    /// </field>
    /// <field name="__messageReceived" type="Microsoft.Live.Messenger.MessageReceivedEventHandler">
    /// </field>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Conversation.prototype = {
    
    get_roster: function Microsoft_Live_Messenger_Conversation$get_roster() {
        /// <summary>
        /// Gets the roster (list of participants) for the conversation.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddressCollection"></value>
        return null;
    },
    
    get_typingAddresses: function Microsoft_Live_Messenger_Conversation$get_typingAddresses() {
        /// <summary>
        /// Gets the addresses of the participants that are currently typing within the conversation.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.TypingIMAddressCollection"></value>
        return null;
    },
    
    get_history: function Microsoft_Live_Messenger_Conversation$get_history() {
        /// <summary>
        /// Gets the message history for the conversation.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.MessageHistory"></value>
        return null;
    },
    
    get_closed: function Microsoft_Live_Messenger_Conversation$get_closed() {
        /// <summary>
        /// Gets whether the conversation is closed.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_supportsMultiparty: function Microsoft_Live_Messenger_Conversation$get_supportsMultiparty() {
        /// <summary>
        /// Gets whether multiple particpants are supported within this conversation.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    notifyUserTyped: function Microsoft_Live_Messenger_Conversation$notifyUserTyped() {
        /// <summary>
        /// Notifies the conversation participants that the user (initiator) has typed.
        /// </summary>
    },
    
    inviteAddress: function Microsoft_Live_Messenger_Conversation$inviteAddress(address, userState) {
        /// <summary>
        /// Invites the address to the conversation.
        /// </summary>
        /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
        /// The address to which the invitation will be sent.
        /// </param>
        /// <param name="userState" type="Object">
        /// A user-defined object that is passed to the method invoked when the asynchronous operation completes.
        /// </param>
    },
    
    sendMessage: function Microsoft_Live_Messenger_Conversation$sendMessage(message, userState) {
        /// <summary>
        /// Sends a message to all participants in the conversation.
        /// </summary>
        /// <param name="message" type="Microsoft.Live.Messenger.Message">
        /// The message to send.
        /// </param>
        /// <param name="userState" type="Object">
        /// A user-defined object that is passed to the method invoked when the asynchronous operation completes.
        /// </param>
    },
    
    close: function Microsoft_Live_Messenger_Conversation$close() {
        /// <summary>
        /// Closes the conversation.
        /// </summary>
    },
    
    supportsMessageType: function Microsoft_Live_Messenger_Conversation$supportsMessageType(messageType) {
        /// <summary>
        /// Determines whether the provided message type is supported by this conversation.
        /// </summary>
        /// <param name="messageType" type="Microsoft.Live.Messenger.MessageType">
        /// The message type.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    
    supportsApplicationMessageType: function Microsoft_Live_Messenger_Conversation$supportsApplicationMessageType(id) {
        /// <summary>
        /// Determines whether the provided application message is supported by this conversation.
        /// </summary>
        /// <param name="id" type="String">
        /// The ID of the application message.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    
    isTextMessageValid: function Microsoft_Live_Messenger_Conversation$isTextMessageValid(textMessage) {
        /// <summary>
        /// Determines whether the provided text message is valid within this conversation.
        /// </summary>
        /// <param name="textMessage" type="String">
        /// The text message to validate.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    
    add_inviteAddressCompleted: function Microsoft_Live_Messenger_Conversation$add_inviteAddressCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.Conversation.InviteAddress(Microsoft.Live.Messenger.IMAddress,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__inviteAddressCompleted = Delegate.combine(this.__inviteAddressCompleted, value);
    },
    remove_inviteAddressCompleted: function Microsoft_Live_Messenger_Conversation$remove_inviteAddressCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.Conversation.InviteAddress(Microsoft.Live.Messenger.IMAddress,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__inviteAddressCompleted = Delegate.remove(this.__inviteAddressCompleted, value);
    },
    
    __inviteAddressCompleted: null,
    
    add_sendMessageFailed: function Microsoft_Live_Messenger_Conversation$add_sendMessageFailed(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.Conversation.SendMessage(Microsoft.Live.Messenger.Message,System.Object)" /> has failed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__sendMessageFailed = Delegate.combine(this.__sendMessageFailed, value);
    },
    remove_sendMessageFailed: function Microsoft_Live_Messenger_Conversation$remove_sendMessageFailed(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.Conversation.SendMessage(Microsoft.Live.Messenger.Message,System.Object)" /> has failed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__sendMessageFailed = Delegate.remove(this.__sendMessageFailed, value);
    },
    
    __sendMessageFailed: null,
    
    add_messageReceived: function Microsoft_Live_Messenger_Conversation$add_messageReceived(value) {
        /// <summary>
        /// Occurs when a message has been received.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__messageReceived = Delegate.combine(this.__messageReceived, value);
    },
    remove_messageReceived: function Microsoft_Live_Messenger_Conversation$remove_messageReceived(value) {
        /// <summary>
        /// Occurs when a message has been received.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__messageReceived = Delegate.remove(this.__messageReceived, value);
    },
    
    __messageReceived: null,
    
    add_propertyChanged: function Microsoft_Live_Messenger_Conversation$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Conversation$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    onMessageReceived: function Microsoft_Live_Messenger_Conversation$onMessageReceived(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Conversation.MessageReceived" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.MessageReceivedEventArgs">
        /// A <see cref="T:Microsoft.Live.Messenger.MessageReceivedEventArgs" /> object containing event data.
        /// </param>
        if (this.__messageReceived) {
        }
    },
    
    onInviteAddressCompleted: function Microsoft_Live_Messenger_Conversation$onInviteAddressCompleted(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Conversation.InviteAddressCompleted" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.InviteAddressCompletedEventArgs">
        /// An <see cref="T:Microsoft.Live.Messenger.InviteAddressCompletedEventArgs" /> object containing event data.
        /// </param>
        if (this.__inviteAddressCompleted) {
        }
    },
    
    onSendMessageFailed: function Microsoft_Live_Messenger_Conversation$onSendMessageFailed(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Conversation.SendMessageFailed" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.SendMessageFailedEventArgs">
        /// An <see cref="T:Microsoft.Live.Messenger.SendMessageFailedEventArgs" /> object containing event data.
        /// </param>
        if (this.__sendMessageFailed) {
        }
    },
    
    onPropertyChanged: function Microsoft_Live_Messenger_Conversation$onPropertyChanged(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Conversation.PropertyChanged" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Core.PropertyChangedEventArgs">
        /// </param>
        if (this.__propertyChanged) {
        }
    },
    
    dispose: function Microsoft_Live_Messenger_Conversation$dispose() {
        /// <summary>
        /// Disposes the conversation.
        /// </summary>
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Endpoint

Microsoft.Live.Messenger.Endpoint = function Microsoft_Live_Messenger_Endpoint(address) {
    /// <summary>
    /// Represents a particular endpoint of an instant messaging address.
    /// </summary>
    /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
    /// The instant messaging address.
    /// </param>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Endpoint.prototype = {
    
    get_id: function Microsoft_Live_Messenger_Endpoint$get_id() {
        /// <summary>
        /// Gets the endpoint's unique ID.
        /// </summary>
        /// <value type="Microsoft.Live.Core.Guid"></value>
        return null;
    },
    
    get_imAddress: function Microsoft_Live_Messenger_Endpoint$get_imAddress() {
        /// <summary>
        /// Gets the associated instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_capabilities: function Microsoft_Live_Messenger_Endpoint$get_capabilities() {
        /// <summary>
        /// Gets the capabilities of the endpoint.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Capabilities"></value>
        return null;
    },
    
    get_presence: function Microsoft_Live_Messenger_Endpoint$get_presence() {
        /// <summary>
        /// Gets the presence information associated with the endpoint.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.EndpointPresence"></value>
        return null;
    },
    
    equals: function Microsoft_Live_Messenger_Endpoint$equals(other) {
        /// <summary>
        /// Determines whether the other endpoint equals this one.
        /// </summary>
        /// <param name="other" type="Microsoft.Live.Messenger.Endpoint">
        /// The other endpoint.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_Endpoint$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Endpoint$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_Endpoint$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Endpoint.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Group

Microsoft.Live.Messenger.Group = function Microsoft_Live_Messenger_Group() {
    /// <summary>
    /// Represents a group of instant messaging addresses.
    /// </summary>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Group.prototype = {
    
    get_name: function Microsoft_Live_Messenger_Group$get_name() {
        /// <summary>
        /// Gets or sets the name of the group.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    set_name: function Microsoft_Live_Messenger_Group$set_name(value) {
        /// <summary>
        /// Gets or sets the name of the group.
        /// </summary>
        /// <value type="String"></value>
        return value;
    },
    
    get_contacts: function Microsoft_Live_Messenger_Group$get_contacts() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.ContactCollection" /> that contains the contacts in the group.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.ContactCollection"></value>
        return null;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_Group$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Group$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_Group$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Group.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.IMAddress

Microsoft.Live.Messenger.IMAddress = function Microsoft_Live_Messenger_IMAddress() {
    /// <summary>
    /// Represents an instant messaging address.
    /// </summary>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.IMAddress.prototype = {
    
    get_address: function Microsoft_Live_Messenger_IMAddress$get_address() {
        /// <summary>
        /// Gets a string containing the address.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    get_type: function Microsoft_Live_Messenger_IMAddress$get_type() {
        /// <summary>
        /// Gets the message type of the address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddressType"></value>
        return Microsoft.Live.Messenger.IMAddressType.windowsLive;
    },
    
    get_endpoints: function Microsoft_Live_Messenger_IMAddress$get_endpoints() {
        /// <summary>
        /// Gets the collection of endpoints.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.EndpointCollection"></value>
        return null;
    },
    
    get_capabilities: function Microsoft_Live_Messenger_IMAddress$get_capabilities() {
        /// <summary>
        /// Gets the capabilities of the instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Capabilities"></value>
        return null;
    },
    
    get_presence: function Microsoft_Live_Messenger_IMAddress$get_presence() {
        /// <summary>
        /// Gets the presence information associated with the address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddressPresence"></value>
        return null;
    },
    
    get_isOnline: function Microsoft_Live_Messenger_IMAddress$get_isOnline() {
        /// <summary>
        /// Gets whether the address is online at the moment.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_isFederated: function Microsoft_Live_Messenger_IMAddress$get_isFederated() {
        /// <summary>
        /// Gets whether the address is federated.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_IMAddress$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_IMAddress$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    equals: function Microsoft_Live_Messenger_IMAddress$equals(other) {
        /// <summary>
        /// Determines whether the other instant messaging address equals this one.
        /// </summary>
        /// <param name="other" type="Microsoft.Live.Messenger.IMAddress">
        /// The other address.
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    },
    
    get_isIdentityVerified: function Microsoft_Live_Messenger_IMAddress$get_isIdentityVerified() {
        /// <summary>
        /// Gets whether the Identity is verified.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_networkIconUrl: function Microsoft_Live_Messenger_IMAddress$get_networkIconUrl() {
        /// <summary>
        /// Gets the network icon URL for the instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Core.Uri"></value>
        return null;
    },
    
    _onPropertyChanged: function Microsoft_Live_Messenger_IMAddress$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.IMAddress.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The property name that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.IMAddressCollection

Microsoft.Live.Messenger.IMAddressCollection = function Microsoft_Live_Messenger_IMAddressCollection() {
    /// <summary>
    /// Represents a collection of instant messaging addresses.
    /// </summary>
    Microsoft.Live.Messenger.IMAddressCollection.constructBase(this);
}
Microsoft.Live.Messenger.IMAddressCollection.prototype = {
    
    add: function Microsoft_Live_Messenger_IMAddressCollection$add(address) {
        /// <summary>
        /// Adds an instant messaging address to the collection.
        /// </summary>
        /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
        /// The address to add.
        /// </param>
    },
    
    remove: function Microsoft_Live_Messenger_IMAddressCollection$remove(address) {
        /// <summary>
        /// Removes an instant messaging address from the collection.
        /// </summary>
        /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
        /// The address to remove.
        /// </param>
    },
    get_item: function Microsoft_Live_Messenger_IMAddressCollection$get_item(index) {
        /// <summary>
        /// Gets the <c>IMAddress</c> at the specific index.
        /// </summary>
        /// <param name="index" type="Number" integer="true">
        /// The zero-based index of the <c>IMAddress</c> to get.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.IMAddress">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.IMAddress"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.MessageHistory

Microsoft.Live.Messenger.MessageHistory = function Microsoft_Live_Messenger_MessageHistory() {
    /// <summary>
    /// Represents the message history of a conversation.
    /// </summary>
    Microsoft.Live.Messenger.MessageHistory.constructBase(this);
}
Microsoft.Live.Messenger.MessageHistory.prototype = {
    
    get_lastReceived: function Microsoft_Live_Messenger_MessageHistory$get_lastReceived() {
        /// <summary>
        /// Gets the last time a message was received.
        /// </summary>
        /// <value type="Date"></value>
        return Date.get_now();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Message

Microsoft.Live.Messenger.Message = function Microsoft_Live_Messenger_Message(messageType) {
    /// <summary>
    /// Represents a message that is sent between instant messaging addresses.
    /// </summary>
    /// <param name="messageType" type="Microsoft.Live.Messenger.MessageType">
    /// The message type.
    /// </param>
}
Microsoft.Live.Messenger.Message.prototype = {
    
    get_sender: function Microsoft_Live_Messenger_Message$get_sender() {
        /// <summary>
        /// Gets the sending instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_type: function Microsoft_Live_Messenger_Message$get_type() {
        /// <summary>
        /// Gets the message type.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.MessageType"></value>
        return Microsoft.Live.Messenger.MessageType.textMessage;
    },
    
    get_timestamp: function Microsoft_Live_Messenger_Message$get_timestamp() {
        /// <summary>
        /// Gets the timestamp the message was sent or received.
        /// </summary>
        /// <value type="Date"></value>
        return Date.get_now();
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.NudgeMessage

Microsoft.Live.Messenger.NudgeMessage = function Microsoft_Live_Messenger_NudgeMessage() {
    /// <summary>
    /// Represents a nudge message.
    /// </summary>
    Microsoft.Live.Messenger.NudgeMessage.constructBase(this, [ Microsoft.Live.Messenger.MessageType.nudgeMessage ]);
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.TextMessage

Microsoft.Live.Messenger.TextMessage = function Microsoft_Live_Messenger_TextMessage(text, format) {
    /// <summary>
    /// Represents a text message.
    /// </summary>
    /// <param name="text" type="String">
    /// The text message content.
    /// </param>
    /// <param name="format" type="Microsoft.Live.Messenger.TextMessageFormat">
    /// The text message format.
    /// </param>
    Microsoft.Live.Messenger.TextMessage.constructBase(this, [ Microsoft.Live.Messenger.MessageType.textMessage ]);
}
Microsoft.Live.Messenger.TextMessage.prototype = {
    
    get_format: function Microsoft_Live_Messenger_TextMessage$get_format() {
        /// <summary>
        /// Gets the text message format.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.TextMessageFormat"></value>
        return null;
    },
    
    get_text: function Microsoft_Live_Messenger_TextMessage$get_text() {
        /// <summary>
        /// Gets the text message content.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    createTextElement: function Microsoft_Live_Messenger_TextMessage$createTextElement() {
        /// <summary>
        /// Creates a DOM element containing the contents of the text message.
        /// </summary>
        /// <returns type="Object" domElement="true"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.TextMessageFormat

Microsoft.Live.Messenger.TextMessageFormat = function Microsoft_Live_Messenger_TextMessageFormat(fontColor, fontFamily, fontStyle, flowDirection) {
    /// <summary>
    /// Represents formatting for a <see cref="T:Microsoft.Live.Messenger.TextMessage" />.
    /// </summary>
    /// <param name="fontColor" type="Microsoft.Live.Messenger.TextMessageColor">
    /// The font color.
    /// </param>
    /// <param name="fontFamily" type="String">
    /// The font family.
    /// </param>
    /// <param name="fontStyle" type="Microsoft.Live.Messenger.TextMessageStyle">
    /// The font style.
    /// </param>
    /// <param name="flowDirection" type="Microsoft.Live.Messenger.TextMessageDirection">
    /// The flow direction of text.
    /// </param>
}
Microsoft.Live.Messenger.TextMessageFormat.get_defaultFormat = function Microsoft_Live_Messenger_TextMessageFormat$get_defaultFormat() {
    /// <summary>
    /// Gets the default text message format.
    /// </summary>
    /// <value type="Microsoft.Live.Messenger.TextMessageFormat"></value>
    return null;
}
Microsoft.Live.Messenger.TextMessageFormat.prototype = {
    
    get_fontColor: function Microsoft_Live_Messenger_TextMessageFormat$get_fontColor() {
        /// <summary>
        /// Gets the font color.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.TextMessageColor"></value>
        return null;
    },
    
    get_fontFamily: function Microsoft_Live_Messenger_TextMessageFormat$get_fontFamily() {
        /// <summary>
        /// Gets the font family.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    get_fontStyle: function Microsoft_Live_Messenger_TextMessageFormat$get_fontStyle() {
        /// <summary>
        /// Gets the font style.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.TextMessageStyle"></value>
        return Microsoft.Live.Messenger.TextMessageStyle.regular;
    },
    
    get_flowDirection: function Microsoft_Live_Messenger_TextMessageFormat$get_flowDirection() {
        /// <summary>
        /// Gets the content flow direction for text and user interface (UI) elements.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.TextMessageDirection"></value>
        return Microsoft.Live.Messenger.TextMessageDirection.leftToRight;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.TextMessageColor

Microsoft.Live.Messenger.TextMessageColor = function Microsoft_Live_Messenger_TextMessageColor() {
    /// <summary>
    /// Represents a color.
    /// </summary>
}
Microsoft.Live.Messenger.TextMessageColor.fromRgb = function Microsoft_Live_Messenger_TextMessageColor$fromRgb(r, g, b) {
    /// <summary>
    /// Creates a <see cref="T:Microsoft.Live.Messenger.TextMessageColor" /> structure from the specified 8-bit color values (red, green, and blue).
    /// </summary>
    /// <param name="r" type="Number" integer="true">
    /// The red component.
    /// </param>
    /// <param name="g" type="Number" integer="true">
    /// The green component.
    /// </param>
    /// <param name="b" type="Number" integer="true">
    /// The blue component.
    /// </param>
    /// <returns type="Microsoft.Live.Messenger.TextMessageColor"></returns>
    return null;
}
Microsoft.Live.Messenger.TextMessageColor.prototype = {
    
    get_r: function Microsoft_Live_Messenger_TextMessageColor$get_r() {
        /// <summary>
        /// Gets the red component value of this <see cref="T:Microsoft.Live.Messenger.TextMessageColor" /> structure.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_g: function Microsoft_Live_Messenger_TextMessageColor$get_g() {
        /// <summary>
        /// Gets the green component value of this <see cref="T:Microsoft.Live.Messenger.TextMessageColor" /> structure.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_b: function Microsoft_Live_Messenger_TextMessageColor$get_b() {
        /// <summary>
        /// Gets the blue component value of this <see cref="T:Microsoft.Live.Messenger.TextMessageColor" /> structure.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.PremiumFeature

Microsoft.Live.Messenger.PremiumFeature = function Microsoft_Live_Messenger_PremiumFeature() {
    /// <summary>
    /// Specifies a premium feature available to the user.
    /// </summary>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.PremiumFeature.prototype = {
    
    get_provisioned: function Microsoft_Live_Messenger_PremiumFeature$get_provisioned() {
        /// <summary>
        /// Gets whether the feature is provisioned.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_enabled: function Microsoft_Live_Messenger_PremiumFeature$get_enabled() {
        /// <summary>
        /// Gets whether the feature is enabled.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_suspended: function Microsoft_Live_Messenger_PremiumFeature$get_suspended() {
        /// <summary>
        /// Gets whether the feature is suspended.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_PremiumFeature$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_PremiumFeature$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_PremiumFeature$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.PremiumFeature.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.PresencePropertyCollection

Microsoft.Live.Messenger.PresencePropertyCollection = function Microsoft_Live_Messenger_PresencePropertyCollection() {
    /// <summary>
    /// Represents a presence property collection.
    /// </summary>
    Microsoft.Live.Messenger.PresencePropertyCollection.constructBase(this);
}
Microsoft.Live.Messenger.PresencePropertyCollection.prototype = {
    get_item: function Microsoft_Live_Messenger_PresencePropertyCollection$get_item(name) {
        /// <summary>
        /// Gets the <c>PresenceProperty</c> by name.
        /// </summary>
        /// <param name="name" type="String">
        /// The name of the <c>PresenceProperty</c>.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.PresenceProperty">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.PresenceProperty"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.User

Microsoft.Live.Messenger.User = function Microsoft_Live_Messenger_User(identity) {
    /// <summary>
    /// Represents a Windows Live Messenger user.
    /// </summary>
    /// <param name="identity" type="Microsoft.Live.Core.Identity">
    /// The identity (Live ID) of the user.
    /// </param>
    /// <field name="__addContactCompleted" type="Microsoft.Live.Messenger.AddContactCompletedEventHandler">
    /// </field>
    /// <field name="__signedOutRemotely" type="Microsoft.Live.Messenger.SignedOutRemotelyEventHandler">
    /// </field>
    /// <field name="__signInCompleted" type="Microsoft.Live.Messenger.SignInCompletedEventHandler">
    /// </field>
    /// <field name="__signOutCompleted" type="Microsoft.Live.Messenger.SignOutCompletedEventHandler">
    /// </field>
    /// <field name="__signOutEndpointCompleted" type="Microsoft.Live.Messenger.SignOutCompletedEventHandler">
    /// </field>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.User.prototype = {
    
    get_identity: function Microsoft_Live_Messenger_User$get_identity() {
        /// <summary>
        /// Gets the <see cref="P:Microsoft.Live.Messenger.User.Identity" /> (Live ID) for the user.
        /// </summary>
        /// <value type="Microsoft.Live.Core.Identity"></value>
        return null;
    },
    
    get_address: function Microsoft_Live_Messenger_User$get_address() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.IMAddress" /> for the user.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_presence: function Microsoft_Live_Messenger_User$get_presence() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.IMAddressPresence" /> for the user.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddressPresence"></value>
        return null;
    },
    
    get_endpoints: function Microsoft_Live_Messenger_User$get_endpoints() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.EndpointCollection" /> for the user.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.EndpointCollection"></value>
        return null;
    },
    
    get_localEndpoint: function Microsoft_Live_Messenger_User$get_localEndpoint() {
        /// <summary>
        /// Gets the local <see cref="T:Microsoft.Live.Messenger.Endpoint" /> for the user.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Endpoint"></value>
        return null;
    },
    
    get_conversations: function Microsoft_Live_Messenger_User$get_conversations() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.ConversationCollection" /> for the user.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.ConversationCollection"></value>
        return null;
    },
    
    get_contacts: function Microsoft_Live_Messenger_User$get_contacts() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.ContactCollection" /> containing all of the user's contacts.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.ContactCollection"></value>
        return null;
    },
    
    get_allowedContacts: function Microsoft_Live_Messenger_User$get_allowedContacts() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.ContactCollection" /> containing all of the user's allowed contacts.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.ContactCollection"></value>
        return null;
    },
    
    get_blockedContacts: function Microsoft_Live_Messenger_User$get_blockedContacts() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.ContactCollection" /> containing all of the user's blocked contacts.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.ContactCollection"></value>
        return null;
    },
    
    get_pendingContacts: function Microsoft_Live_Messenger_User$get_pendingContacts() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.ContactCollection" /> containing all of the user's pending contacts.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PendingContactCollection"></value>
        return null;
    },
    
    get_groups: function Microsoft_Live_Messenger_User$get_groups() {
        /// <summary>
        /// Gets the <see cref="T:Microsoft.Live.Messenger.GroupCollection" /> containing all of the user's groups.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.GroupCollection"></value>
        return null;
    },
    
    get_settings: function Microsoft_Live_Messenger_User$get_settings() {
        /// <summary>
        /// Gets the <see cref="P:Microsoft.Live.Messenger.User.Settings" /> containing the user's privacy options.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Settings"></value>
        return null;
    },
    
    get_mailbox: function Microsoft_Live_Messenger_User$get_mailbox() {
        /// <summary>
        /// Gets the user's <see cref="P:Microsoft.Live.Messenger.User.Mailbox" />.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Mailbox"></value>
        return null;
    },
    
    get_messageFactory: function Microsoft_Live_Messenger_User$get_messageFactory() {
        /// <summary>
        /// The message factory that allows for custom messages to be sent and received.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Messaging.ApplicationMessageFactory"></value>
        return null;
    },
    set_messageFactory: function Microsoft_Live_Messenger_User$set_messageFactory(value) {
        /// <summary>
        /// The message factory that allows for custom messages to be sent and received.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Messaging.ApplicationMessageFactory"></value>
        return value;
    },
    
    get_presenceFactory: function Microsoft_Live_Messenger_User$get_presenceFactory() {
        /// <summary>
        /// The presence factory that allows custom presence properties to be used.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Presence.PresenceExtensionFactory"></value>
        return null;
    },
    set_presenceFactory: function Microsoft_Live_Messenger_User$set_presenceFactory(value) {
        /// <summary>
        /// The presence factory that allows custom presence properties to be used.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.Presence.PresenceExtensionFactory"></value>
        return value;
    },
    
    add_addContactCompleted: function Microsoft_Live_Messenger_User$add_addContactCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.AddContact(System.String,System.String,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__addContactCompleted = Delegate.combine(this.__addContactCompleted, value);
    },
    remove_addContactCompleted: function Microsoft_Live_Messenger_User$remove_addContactCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.AddContact(System.String,System.String,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__addContactCompleted = Delegate.remove(this.__addContactCompleted, value);
    },
    
    __addContactCompleted: null,
    
    add_signedOutRemotely: function Microsoft_Live_Messenger_User$add_signedOutRemotely(value) {
        /// <summary>
        /// Occurs when the user has been signed out remotely.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signedOutRemotely = Delegate.combine(this.__signedOutRemotely, value);
    },
    remove_signedOutRemotely: function Microsoft_Live_Messenger_User$remove_signedOutRemotely(value) {
        /// <summary>
        /// Occurs when the user has been signed out remotely.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signedOutRemotely = Delegate.remove(this.__signedOutRemotely, value);
    },
    
    __signedOutRemotely: null,
    
    add_signInCompleted: function Microsoft_Live_Messenger_User$add_signInCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.SignIn(System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signInCompleted = Delegate.combine(this.__signInCompleted, value);
    },
    remove_signInCompleted: function Microsoft_Live_Messenger_User$remove_signInCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.SignIn(System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signInCompleted = Delegate.remove(this.__signInCompleted, value);
    },
    
    __signInCompleted: null,
    
    add_signOutCompleted: function Microsoft_Live_Messenger_User$add_signOutCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.SignOut(Microsoft.Live.Messenger.SignOutLocations,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signOutCompleted = Delegate.combine(this.__signOutCompleted, value);
    },
    remove_signOutCompleted: function Microsoft_Live_Messenger_User$remove_signOutCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.SignOut(Microsoft.Live.Messenger.SignOutLocations,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signOutCompleted = Delegate.remove(this.__signOutCompleted, value);
    },
    
    __signOutCompleted: null,
    
    add_signOutEndpointCompleted: function Microsoft_Live_Messenger_User$add_signOutEndpointCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.SignOutEndpoint(Microsoft.Live.Messenger.Endpoint,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signOutEndpointCompleted = Delegate.combine(this.__signOutEndpointCompleted, value);
    },
    remove_signOutEndpointCompleted: function Microsoft_Live_Messenger_User$remove_signOutEndpointCompleted(value) {
        /// <summary>
        /// Occurs when <see cref="M:Microsoft.Live.Messenger.User.SignOutEndpoint(Microsoft.Live.Messenger.Endpoint,System.Object)" /> has completed.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__signOutEndpointCompleted = Delegate.remove(this.__signOutEndpointCompleted, value);
    },
    
    __signOutEndpointCompleted: null,
    
    add_propertyChanged: function Microsoft_Live_Messenger_User$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when the value of a property changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_User$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when the value of a property changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    signIn: function Microsoft_Live_Messenger_User$signIn(userState) {
        /// <summary>
        /// Signs the user into the Messenger service.
        /// </summary>
        /// <param name="userState" type="Object">
        /// A user-defined object that is passed to the method invoked when the asynchronous operation completes.
        /// </param>
    },
    
    signOut: function Microsoft_Live_Messenger_User$signOut(locations, userState) {
        /// <summary>
        /// Signs the provided locations out from the service.
        /// </summary>
        /// <param name="locations" type="Microsoft.Live.Messenger.SignOutLocations">
        /// The locations that should be signed out from the service.
        /// </param>
        /// <param name="userState" type="Object">
        /// A user-defined object that is passed to the method invoked when the asynchronous operation completes.
        /// </param>
    },
    
    signOutEndpoint: function Microsoft_Live_Messenger_User$signOutEndpoint(endpoint, userState) {
        /// <summary>
        /// Signs the provided endpoint out from the service.
        /// </summary>
        /// <param name="endpoint" type="Microsoft.Live.Messenger.Endpoint">
        /// The endpoint to be signed out.
        /// </param>
        /// <param name="userState" type="Object">
        /// A user-defined object that is passed to the method invoked when the asynchronous operation completes.
        /// </param>
    },
    
    addContact: function Microsoft_Live_Messenger_User$addContact(address, inviteMessage, userState) {
        /// <summary>
        /// Adds a contact to the user's buddy list.
        /// </summary>
        /// <param name="address" type="String">
        /// The address of the contact to add.
        /// </param>
        /// <param name="inviteMessage" type="String">
        /// The invitation message to display to the invited contact.
        /// </param>
        /// <param name="userState" type="Object">
        /// A user-defined object that is passed to the method invoked when the asynchronous operation completes.
        /// </param>
    },
    
    onAddContactCompleted: function Microsoft_Live_Messenger_User$onAddContactCompleted(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.User.AddContactCompleted" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.AddContactCompletedEventArgs">
        /// An <see cref="T:Microsoft.Live.Messenger.AddContactCompletedEventArgs" /> object containing event data.
        /// </param>
        if (this.__addContactCompleted) {
            this.__addContactCompleted.invoke(this, e);
        }
    },
    
    onSignInCompleted: function Microsoft_Live_Messenger_User$onSignInCompleted(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.User.SignInCompleted" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.SignInCompletedEventArgs">
        /// A <see cref="T:Microsoft.Live.Messenger.SignInCompletedEventArgs" /> object containing event data.
        /// </param>
        if (this.__signInCompleted) {
            this.__signInCompleted.invoke(this, e);
        }
    },
    
    onSignOutCompleted: function Microsoft_Live_Messenger_User$onSignOutCompleted(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.User.SignOutCompleted" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.SignOutCompletedEventArgs">
        /// A <see cref="T:Microsoft.Live.Messenger.SignOutCompletedEventArgs" /> object containing event data.
        /// </param>
        if (this.__signOutCompleted) {
            this.__signOutCompleted.invoke(this, e);
        }
    },
    
    onSignOutEndpointCompleted: function Microsoft_Live_Messenger_User$onSignOutEndpointCompleted(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.User.SignOutEndpointCompleted" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.SignOutCompletedEventArgs">
        /// A <see cref="T:Microsoft.Live.Messenger.SignOutCompletedEventArgs" /> object containing event data.
        /// </param>
        if (this.__signOutEndpointCompleted) {
            this.__signOutEndpointCompleted.invoke(this, e);
        }
    },
    
    onSignedOutRemotely: function Microsoft_Live_Messenger_User$onSignedOutRemotely(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.User.SignedOutRemotely" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.SignedOutRemotelyEventArgs">
        /// A <see cref="T:Microsoft.Live.Messenger.SignedOutRemotelyEventArgs" /> object containing event data.
        /// </param>
        if (this.__signedOutRemotely) {
            this.__signedOutRemotely.invoke(this, e);
        }
    },
    
    _onPropertyChanged: function Microsoft_Live_Messenger_User$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.User.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    },
    
    onCreateMailbox: function Microsoft_Live_Messenger_User$onCreateMailbox() {
        /// <summary>
        /// Occurs when the user's mailbox is created.
        /// </summary>
        /// <returns type="Microsoft.Live.Messenger.Mailbox"></returns>
        return null;
    },
    
    onCreateConversation: function Microsoft_Live_Messenger_User$onCreateConversation(address) {
        /// <summary>
        /// Occurs when a conversation is created.
        /// </summary>
        /// <param name="address" type="Microsoft.Live.Messenger.IMAddress">
        /// The instant messaging address associated with the conversation.
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Conversation"></returns>
        return null;
    },
    
    dispose: function Microsoft_Live_Messenger_User$dispose() {
        /// <summary>
        /// Disposes the service.
        /// </summary>
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Settings

Microsoft.Live.Messenger.Settings = function Microsoft_Live_Messenger_Settings() {
    /// <summary>
    /// Encapsulates the user's settings.
    /// </summary>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Settings.prototype = {
    
    get_privacyMode: function Microsoft_Live_Messenger_Settings$get_privacyMode() {
        /// <summary>
        /// Gets or sets the user's privacy mode.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PrivacyMode"></value>
        return Microsoft.Live.Messenger.PrivacyMode.blockByDefault;
    },
    set_privacyMode: function Microsoft_Live_Messenger_Settings$set_privacyMode(value) {
        /// <summary>
        /// Gets or sets the user's privacy mode.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PrivacyMode"></value>
        return value;
    },
    
    get_canUpdateDisplayName: function Microsoft_Live_Messenger_Settings$get_canUpdateDisplayName() {
        /// <summary>
        /// Gets whether the user's display name can be updated.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_hasMailbox: function Microsoft_Live_Messenger_Settings$get_hasMailbox() {
        /// <summary>
        /// Gets whether the user has a Windows Live Hotmail mailbox.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    
    get_prepaidMobileMessaging: function Microsoft_Live_Messenger_Settings$get_prepaidMobileMessaging() {
        /// <summary>
        /// Gets the prepaid mobile messaging feature.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PremiumFeature"></value>
        return null;
    },
    
    get_partnerMobileMessaging: function Microsoft_Live_Messenger_Settings$get_partnerMobileMessaging() {
        /// <summary>
        /// Gest the partner mobile messaging feature.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.PremiumFeature"></value>
        return null;
    },
    
    get_multipleEndpointsEnabled: function Microsoft_Live_Messenger_Settings$get_multipleEndpointsEnabled() {
        /// <summary>
        /// Gets or sets whether the user has enabled support for simultaenous login of multiple endpoints.
        /// </summary>
        /// <value type="Boolean"></value>
        return false;
    },
    set_multipleEndpointsEnabled: function Microsoft_Live_Messenger_Settings$set_multipleEndpointsEnabled(value) {
        /// <summary>
        /// Gets or sets whether the user has enabled support for simultaenous login of multiple endpoints.
        /// </summary>
        /// <value type="Boolean"></value>
        return value;
    },
    
    add_propertyChanged: function Microsoft_Live_Messenger_Settings$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Settings$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    _onPropertyChanged: function Microsoft_Live_Messenger_Settings$_onPropertyChanged(propertyName) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Settings.PropertyChanged" /> event.
        /// </summary>
        /// <param name="propertyName" type="String">
        /// The name of the property that changed.
        /// </param>
        if (this.__propertyChanged) {
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.EmailReceivedEventArgs

Microsoft.Live.Messenger.EmailReceivedEventArgs = function Microsoft_Live_Messenger_EmailReceivedEventArgs(subject, sender, senderAddress, messageUrl, folder) {
    /// <summary>
    /// Provides data for the <see cref="E:Microsoft.Live.Messenger.Mailbox.EmailReceived" /> event of <see cref="T:Microsoft.Live.Messenger.Mailbox" />.
    /// </summary>
    /// <param name="subject" type="String">
    /// The subject of the email.
    /// </param>
    /// <param name="sender" type="String">
    /// The sender of the email.
    /// </param>
    /// <param name="senderAddress" type="String">
    /// The address of the sender of the email.
    /// </param>
    /// <param name="messageUrl" type="Microsoft.Live.Core.Uri">
    /// The URL of the email.
    /// </param>
    /// <param name="folder" type="Microsoft.Live.Messenger.MailFolder">
    /// The folder
    /// </param>
    Microsoft.Live.Messenger.EmailReceivedEventArgs.constructBase(this);
}
Microsoft.Live.Messenger.EmailReceivedEventArgs.prototype = {
    
    get_subject: function Microsoft_Live_Messenger_EmailReceivedEventArgs$get_subject() {
        /// <summary>
        /// Gets the subject of the email.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    get_sender: function Microsoft_Live_Messenger_EmailReceivedEventArgs$get_sender() {
        /// <summary>
        /// Gets the sender of the email.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    get_senderAddress: function Microsoft_Live_Messenger_EmailReceivedEventArgs$get_senderAddress() {
        /// <summary>
        /// Gets the address of the sender of the email.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    get_messageUrl: function Microsoft_Live_Messenger_EmailReceivedEventArgs$get_messageUrl() {
        /// <summary>
        /// Gets the URL of the email.
        /// </summary>
        /// <value type="Microsoft.Live.Core.Uri"></value>
        return null;
    },
    
    get_folder: function Microsoft_Live_Messenger_EmailReceivedEventArgs$get_folder() {
        /// <summary>
        /// The folder the email ended up in.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.MailFolder"></value>
        return Microsoft.Live.Messenger.MailFolder.inbox;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Mailbox

Microsoft.Live.Messenger.Mailbox = function Microsoft_Live_Messenger_Mailbox(user) {
    /// <summary>
    /// Represents the user's Windows Live Hotmail mailbox.
    /// </summary>
    /// <param name="user" type="Microsoft.Live.Messenger.User">
    /// The associated user.
    /// </param>
    /// <field name="__emailReceived" type="Microsoft.Live.Messenger.EmailReceivedEventHandler">
    /// </field>
    /// <field name="__propertyChanged" type="Microsoft.Live.Core.PropertyChangedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.Mailbox.prototype = {
    
    get_inboxInitialCount: function Microsoft_Live_Messenger_Mailbox$get_inboxInitialCount() {
        /// <summary>
        /// Gets the initial mail count of the inbox.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_inboxUnreadCount: function Microsoft_Live_Messenger_Mailbox$get_inboxUnreadCount() {
        /// <summary>
        /// Gets the current unread mail count of the inbox.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_otherInitialCount: function Microsoft_Live_Messenger_Mailbox$get_otherInitialCount() {
        /// <summary>
        /// Gets the initial mail count for all folders.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    get_otherUnreadCount: function Microsoft_Live_Messenger_Mailbox$get_otherUnreadCount() {
        /// <summary>
        /// Gets the current unread mail count for all folders.
        /// </summary>
        /// <value type="Number" integer="true"></value>
        return 0;
    },
    
    add_emailReceived: function Microsoft_Live_Messenger_Mailbox$add_emailReceived(value) {
        /// <summary>
        /// Occurs when the user receives an email.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__emailReceived = Delegate.combine(this.__emailReceived, value);
    },
    remove_emailReceived: function Microsoft_Live_Messenger_Mailbox$remove_emailReceived(value) {
        /// <summary>
        /// Occurs when the user receives an email.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__emailReceived = Delegate.remove(this.__emailReceived, value);
    },
    
    __emailReceived: null,
    
    add_propertyChanged: function Microsoft_Live_Messenger_Mailbox$add_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.combine(this.__propertyChanged, value);
    },
    remove_propertyChanged: function Microsoft_Live_Messenger_Mailbox$remove_propertyChanged(value) {
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__propertyChanged = Delegate.remove(this.__propertyChanged, value);
    },
    
    __propertyChanged: null,
    
    onEmailReceived: function Microsoft_Live_Messenger_Mailbox$onEmailReceived(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Mailbox.EmailReceived" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Messenger.EmailReceivedEventArgs">
        /// An <see cref="T:Microsoft.Live.Messenger.EmailReceivedEventArgs" /> that contains the event data.
        /// </param>
        if (this.__emailReceived) {
            this.__emailReceived.invoke(this, e);
        }
    },
    
    onPropertyChanged: function Microsoft_Live_Messenger_Mailbox$onPropertyChanged(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.Mailbox.PropertyChanged" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Core.PropertyChangedEventArgs">
        /// A <see cref="T:Microsoft.Live.Core.PropertyChangedEventArgs" /> that contains the event data.
        /// </param>
        if (this.__propertyChanged) {
            this.__propertyChanged.invoke(this, e);
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.PendingContact

Microsoft.Live.Messenger.PendingContact = function Microsoft_Live_Messenger_PendingContact() {
    /// <summary>
    /// Specifies a pending contact.
    /// </summary>
}
Microsoft.Live.Messenger.PendingContact.prototype = {
    
    get_imAddress: function Microsoft_Live_Messenger_PendingContact$get_imAddress() {
        /// <summary>
        /// Gets the instant messaging address.
        /// </summary>
        /// <value type="Microsoft.Live.Messenger.IMAddress"></value>
        return null;
    },
    
    get_inviteMessage: function Microsoft_Live_Messenger_PendingContact$get_inviteMessage() {
        /// <summary>
        /// Gets the invite message that the address provided.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    accept: function Microsoft_Live_Messenger_PendingContact$accept() {
        /// <summary>
        /// Accepts the pending contact.
        /// </summary>
    },
    
    decline: function Microsoft_Live_Messenger_PendingContact$decline() {
        /// <summary>
        /// Declines the pending contact.
        /// </summary>
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.PendingContactCollection

Microsoft.Live.Messenger.PendingContactCollection = function Microsoft_Live_Messenger_PendingContactCollection() {
    /// <summary>
    /// Represents a collection of pending contacts.
    /// </summary>
    Microsoft.Live.Messenger.PendingContactCollection.constructBase(this);
}
Microsoft.Live.Messenger.PendingContactCollection.prototype = {
    
    accept: function Microsoft_Live_Messenger_PendingContactCollection$accept(contact) {
        /// <summary>
        /// Accepts a pending contact and removes it from the collection.
        /// </summary>
        /// <param name="contact" type="Microsoft.Live.Messenger.PendingContact">
        /// The contact to accept.
        /// </param>
    },
    
    decline: function Microsoft_Live_Messenger_PendingContactCollection$decline(contact) {
        /// <summary>
        /// Declines a pending contact and removes it from the collection.
        /// </summary>
        /// <param name="contact" type="Microsoft.Live.Messenger.PendingContact">
        /// The contact to decline.
        /// </param>
    },
    get_item: function Microsoft_Live_Messenger_PendingContactCollection$get_item(index) {
        /// <summary>
        /// Gets the <c>PendingContact</c> at the specific index.
        /// </summary>
        /// <param name="index" type="Number" integer="true">
        /// The zero-based index of the <c>PendingContact</c> to get.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.PendingContact">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.PendingContact"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.TypingIMAddressCollection

Microsoft.Live.Messenger.TypingIMAddressCollection = function Microsoft_Live_Messenger_TypingIMAddressCollection() {
    /// <summary>
    /// Contains the instant messaging addresses that are typing within the <c>Conversation</c>.
    /// </summary>
    Microsoft.Live.Messenger.TypingIMAddressCollection.constructBase(this);
}
Microsoft.Live.Messenger.TypingIMAddressCollection.prototype = {
    get_item: function Microsoft_Live_Messenger_TypingIMAddressCollection$get_item(index) {
        /// <summary>
        /// Gets the <c>IMAddress</c> at the specific index.
        /// </summary>
        /// <param name="index" type="Number" integer="true">
        /// The zero-based index of the <c>IMAddress</c> to get.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.IMAddress">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.IMAddress"></returns>
        return null;
    }
}


Type.createNamespace('Microsoft.Live.Messenger.Messaging');

////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Messaging.ApplicationMessage

Microsoft.Live.Messenger.Messaging.ApplicationMessage = function Microsoft_Live_Messenger_Messaging_ApplicationMessage() {
    /// <summary>
    /// Represents the message that can be inherited from to create customized messages.
    /// </summary>
    Microsoft.Live.Messenger.Messaging.ApplicationMessage.constructBase(this, [ Microsoft.Live.Messenger.MessageType.applicationMessage ]);
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Messaging.ApplicationMessageFactory

Microsoft.Live.Messenger.Messaging.ApplicationMessageFactory = function Microsoft_Live_Messenger_Messaging_ApplicationMessageFactory(user) {
    /// <summary>
    /// A factory class that must be derived from in order to implement custom messages. The factory
    /// takes care of deserializing incoming messages and allows for registering and promoting messages
    /// to other applications.
    /// </summary>
    /// <param name="user" type="Microsoft.Live.Messenger.User">
    /// The user this factory is for
    /// </param>
}
Microsoft.Live.Messenger.Messaging.ApplicationMessageFactory.prototype = {
    
    register: function Microsoft_Live_Messenger_Messaging_ApplicationMessageFactory$register(id) {
        /// <summary>
        /// Registers the ID for a custom message. Once an ID has been registered, it will be promoted to
        /// other applications to make them aware your application supports the given custom message.
        /// </summary>
        /// <param name="id" type="String">
        /// The ID to register
        /// </param>
    },
    
    unregister: function Microsoft_Live_Messenger_Messaging_ApplicationMessageFactory$unregister(id) {
        /// <summary>
        /// Unregisters an ID, might your application no longer support it.
        /// </summary>
        /// <param name="id" type="String">
        /// The ID to register
        /// </param>
    },
    
    isRegistered: function Microsoft_Live_Messenger_Messaging_ApplicationMessageFactory$isRegistered(id) {
        /// <summary>
        /// Checks if a given ID has already been registered.
        /// </summary>
        /// <param name="id" type="String">
        /// The ID to check for
        /// </param>
        /// <returns type="Boolean"></returns>
        return false;
    }
}


Type.createNamespace('Microsoft.Live.Messenger.Presence');

////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Presence.PresenceExtension

Microsoft.Live.Messenger.Presence.PresenceExtension = function Microsoft_Live_Messenger_Presence_PresenceExtension(name) {
    /// <summary>
    /// Base class for custom presence properties.
    /// </summary>
    /// <param name="name" type="String">
    /// The name of the property
    /// </param>
}
Microsoft.Live.Messenger.Presence.PresenceExtension.prototype = {
    
    get_name: function Microsoft_Live_Messenger_Presence_PresenceExtension$get_name() {
        /// <summary>
        /// The name of the property.
        /// </summary>
        /// <value type="String"></value>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Presence.PresenceExtensionCollection

Microsoft.Live.Messenger.Presence.PresenceExtensionCollection = function Microsoft_Live_Messenger_Presence_PresenceExtensionCollection() {
    /// <summary>
    /// Represents a collection of presence extensions.
    /// </summary>
    Microsoft.Live.Messenger.Presence.PresenceExtensionCollection.constructBase(this);
}
Microsoft.Live.Messenger.Presence.PresenceExtensionCollection.prototype = {
    
    add: function Microsoft_Live_Messenger_Presence_PresenceExtensionCollection$add(property) {
        /// <summary>
        /// Adds a new custom property.
        /// </summary>
        /// <param name="property" type="Microsoft.Live.Messenger.Presence.PresenceExtension">
        /// The property to add
        /// </param>
    },
    
    remove: function Microsoft_Live_Messenger_Presence_PresenceExtensionCollection$remove(property) {
        /// <summary>
        /// Removes a custom property.
        /// </summary>
        /// <param name="property" type="Microsoft.Live.Messenger.Presence.PresenceExtension">
        /// The property to remove
        /// </param>
    },
    get_item: function Microsoft_Live_Messenger_Presence_PresenceExtensionCollection$get_item(name) {
        /// <summary>
        /// Gets the <c>PresenceExtension</c> by name.
        /// </summary>
        /// <param name="name" type="String">
        /// The name of the <c>PresenceExtension</c>.
        /// </param>
        /// <param name="value" type="Microsoft.Live.Messenger.Presence.PresenceExtension">
        /// </param>
        /// <returns type="Microsoft.Live.Messenger.Presence.PresenceExtension"></returns>
        return null;
    }
}


////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.Presence.PresenceExtensionFactory

Microsoft.Live.Messenger.Presence.PresenceExtensionFactory = function Microsoft_Live_Messenger_Presence_PresenceExtensionFactory() {
    /// <summary>
    /// Factory class that must be derived from in order to add custom presence properties.
    /// </summary>
}


Type.createNamespace('Microsoft.Live.Messenger.UI');

////////////////////////////////////////////////////////////////////////////////
// Microsoft.Live.Messenger.UI.SignInControl

Microsoft.Live.Messenger.UI.SignInControl = function Microsoft_Live_Messenger_UI_SignInControl(controlId, privacyStatementUrl, channelUrl, market) {
    /// <summary>
    /// Represents a Windows Live Messenger sign in control.
    /// </summary>
    /// <param name="controlId" type="String">
    /// The ID of the control.
    /// </param>
    /// <param name="privacyStatementUrl" type="String">
    /// The privacy statement URL.
    /// </param>
    /// <param name="channelUrl" type="String">
    /// The channel URL. Optional.
    /// </param>
    /// <param name="market" type="String">
    /// The market. Optional.
    /// </param>
    /// <field name="__authenticationCompleted" type="Microsoft.Live.Core.AuthenticationCompletedEventHandler">
    /// </field>
}
Microsoft.Live.Messenger.UI.SignInControl.prototype = {
    
    get_privacyStatementUrl: function Microsoft_Live_Messenger_UI_SignInControl$get_privacyStatementUrl() {
        /// <summary>
        /// Gets the privacy statement URL.
        /// </summary>
        /// <value type="String"></value>
        return null;
    },
    
    add_authenticationCompleted: function Microsoft_Live_Messenger_UI_SignInControl$add_authenticationCompleted(value) {
        /// <summary>
        /// Occurs when the user has authenticated.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__authenticationCompleted = Delegate.combine(this.__authenticationCompleted, value);
    },
    remove_authenticationCompleted: function Microsoft_Live_Messenger_UI_SignInControl$remove_authenticationCompleted(value) {
        /// <summary>
        /// Occurs when the user has authenticated.
        /// </summary>
        /// <param name="value" type="Function" />
        this.__authenticationCompleted = Delegate.remove(this.__authenticationCompleted, value);
    },
    
    __authenticationCompleted: null,
    
    _onAuthenticationCompleted: function Microsoft_Live_Messenger_UI_SignInControl$_onAuthenticationCompleted(e) {
        /// <summary>
        /// Raises the <see cref="E:Microsoft.Live.Messenger.UI.SignInControl.AuthenticationCompleted" /> event.
        /// </summary>
        /// <param name="e" type="Microsoft.Live.Core.AuthenticationCompletedEventArgs">
        /// An <see cref="T:Microsoft.Live.Core.AuthenticationCompletedEventArgs" /> object containing event data.
        /// </param>
        if (this.__authenticationCompleted) {
            this.__authenticationCompleted.invoke(this, e);
        }
    }
}


Microsoft.Live.Core.AuthenticationCompletedEventArgs.createClass('Microsoft.Live.Core.AuthenticationCompletedEventArgs', EventArgs);
Microsoft.Live.Core.NotifyCollectionChangedEventArgs.createClass('Microsoft.Live.Core.NotifyCollectionChangedEventArgs', EventArgs);
Microsoft.Live.Core.PropertyChangedEventArgs.createClass('Microsoft.Live.Core.PropertyChangedEventArgs', EventArgs);
Microsoft.Live.Core.Guid.createClass('Microsoft.Live.Core.Guid');
Microsoft.Live.Core.Uri.createClass('Microsoft.Live.Core.Uri');
Microsoft.Live.Core.Version.createClass('Microsoft.Live.Core.Version');
Microsoft.Live.Core.Identity.createClass('Microsoft.Live.Core.Identity');
Microsoft.Live.Messenger.AddressChangingEventArgs.createClass('Microsoft.Live.Messenger.AddressChangingEventArgs', EventArgs);
Microsoft.Live.Messenger.IMAddressPresence.createClass('Microsoft.Live.Messenger.IMAddressPresence', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.PresenceProperty.createClass('Microsoft.Live.Messenger.PresenceProperty');
Microsoft.Live.Messenger.Collection.createClass('Microsoft.Live.Messenger.Collection', null, IEnumerable, Microsoft.Live.Core.INotifyCollectionChanged, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.Contact.createClass('Microsoft.Live.Messenger.Contact', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.ContactCollection.createClass('Microsoft.Live.Messenger.ContactCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.EndpointPresence.createClass('Microsoft.Live.Messenger.EndpointPresence', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.ConversationCollection.createClass('Microsoft.Live.Messenger.ConversationCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.EndpointCollection.createClass('Microsoft.Live.Messenger.EndpointCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.AddContactCompletedEventArgs.createClass('Microsoft.Live.Messenger.AddContactCompletedEventArgs', EventArgs);
Microsoft.Live.Messenger.InviteAddressCompletedEventArgs.createClass('Microsoft.Live.Messenger.InviteAddressCompletedEventArgs', EventArgs);
Microsoft.Live.Messenger.MessageReceivedEventArgs.createClass('Microsoft.Live.Messenger.MessageReceivedEventArgs', EventArgs);
Microsoft.Live.Messenger.SendMessageFailedEventArgs.createClass('Microsoft.Live.Messenger.SendMessageFailedEventArgs', EventArgs);
Microsoft.Live.Messenger.SignedOutRemotelyEventArgs.createClass('Microsoft.Live.Messenger.SignedOutRemotelyEventArgs', EventArgs);
Microsoft.Live.Messenger.SignInCompletedEventArgs.createClass('Microsoft.Live.Messenger.SignInCompletedEventArgs', EventArgs);
Microsoft.Live.Messenger.SignOutCompletedEventArgs.createClass('Microsoft.Live.Messenger.SignOutCompletedEventArgs', EventArgs);
Microsoft.Live.Messenger.GroupCollection.createClass('Microsoft.Live.Messenger.GroupCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.Capabilities.createClass('Microsoft.Live.Messenger.Capabilities', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.Conversation.createClass('Microsoft.Live.Messenger.Conversation', null, Microsoft.Live.Core.INotifyPropertyChanged, IDisposable);
Microsoft.Live.Messenger.Endpoint.createClass('Microsoft.Live.Messenger.Endpoint', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.Group.createClass('Microsoft.Live.Messenger.Group', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.IMAddress.createClass('Microsoft.Live.Messenger.IMAddress', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.IMAddressCollection.createClass('Microsoft.Live.Messenger.IMAddressCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.MessageHistory.createClass('Microsoft.Live.Messenger.MessageHistory', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.Message.createClass('Microsoft.Live.Messenger.Message');
Microsoft.Live.Messenger.NudgeMessage.createClass('Microsoft.Live.Messenger.NudgeMessage', Microsoft.Live.Messenger.Message);
Microsoft.Live.Messenger.TextMessage.createClass('Microsoft.Live.Messenger.TextMessage', Microsoft.Live.Messenger.Message);
Microsoft.Live.Messenger.TextMessageFormat.createClass('Microsoft.Live.Messenger.TextMessageFormat');
Microsoft.Live.Messenger.TextMessageColor.createClass('Microsoft.Live.Messenger.TextMessageColor');
Microsoft.Live.Messenger.PremiumFeature.createClass('Microsoft.Live.Messenger.PremiumFeature', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.PresencePropertyCollection.createClass('Microsoft.Live.Messenger.PresencePropertyCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.User.createClass('Microsoft.Live.Messenger.User', null, Microsoft.Live.Core.INotifyPropertyChanged, IDisposable);
Microsoft.Live.Messenger.Settings.createClass('Microsoft.Live.Messenger.Settings', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.EmailReceivedEventArgs.createClass('Microsoft.Live.Messenger.EmailReceivedEventArgs', EventArgs);
Microsoft.Live.Messenger.Mailbox.createClass('Microsoft.Live.Messenger.Mailbox', null, Microsoft.Live.Core.INotifyPropertyChanged);
Microsoft.Live.Messenger.PendingContact.createClass('Microsoft.Live.Messenger.PendingContact');
Microsoft.Live.Messenger.PendingContactCollection.createClass('Microsoft.Live.Messenger.PendingContactCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.TypingIMAddressCollection.createClass('Microsoft.Live.Messenger.TypingIMAddressCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.Messaging.ApplicationMessage.createClass('Microsoft.Live.Messenger.Messaging.ApplicationMessage', Microsoft.Live.Messenger.Message);
Microsoft.Live.Messenger.Messaging.ApplicationMessageFactory.createClass('Microsoft.Live.Messenger.Messaging.ApplicationMessageFactory');
Microsoft.Live.Messenger.Presence.PresenceExtension.createClass('Microsoft.Live.Messenger.Presence.PresenceExtension');
Microsoft.Live.Messenger.Presence.PresenceExtensionCollection.createClass('Microsoft.Live.Messenger.Presence.PresenceExtensionCollection', Microsoft.Live.Messenger.Collection);
Microsoft.Live.Messenger.Presence.PresenceExtensionFactory.createClass('Microsoft.Live.Messenger.Presence.PresenceExtensionFactory');
Microsoft.Live.Messenger.UI.SignInControl.createClass('Microsoft.Live.Messenger.UI.SignInControl');

// ---- Do not remove this footer ----
// Generated using Script# v0.4.5.0 (http://projects.nikhilk.net)
// -----------------------------------
